class B; // #1  here B is an incomplete class
class A
{
public:
  B* pointer_b;

};

class B // here is the definition of B
{
public:
  A* pointer_a;
}; // #2  now B is a complete class type

template<class T>
inline void checked_delete(T * x)
{
    // intentionally complex - simplification causes regressions
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ]; // #1
    (void) sizeof(type_must_be_complete);  // #2
    delete x;
}

private static bool CheckValidationResult(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
{
        return true;
}

//...

ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);

List<X509Certificates> trustCerts;

public static void LoadTrustCerts(string certsPath)
{
  trustCerts = new List<X509Certificates>();
  string[] strFiles = IO.Directory.GetFiles(certPath);
  foreach(string strFile in strFiles)
  {
    if (strFile.Length < 4 || strFile.Substring(strFile.Length - 4) != ".cer" ) { continue;}
    trustCerts.Add(X509Certificates.X509Certificate.CreateFromCertFile(strFile));
  }
}

public static bool CheckSSLCert(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
{
  foreach(X509Certificate cert in trustCerts)
  {
    if cert.Equals(certificate)
    {
      return true;
    }
  }
  return false;
}

ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);

#include <windows.h>
#include <tchar.h>

#include <stdio.h>

const size_t SHAREDMEMSIZE = 1024*1024;

const LPCTSTR SHAREDMEMNAME = _T("testProcessSyncMem");

HANDLE hMapping = 0;

void* pSharedMemAddress = NULL;

const int maxInstCount = 8;


// 共享内存区的数据结构，所有需要共享的变量定义在这个结构里面
struct share_data_t
{
    volatile long numInst; //不要忘了volatile修饰
};

// 这个宏仅仅是为了兼容老版本的Interlocked API接口定义
// (老版本的Interlocked API 将参数声明为LPLONG而不是 LONG volatile*，需要cast)
#define V(x) ((LPLONG)(x))

// 初始化共享内存区，若已有此区则直接获取其地址，否则创建此区
int initSharedMemory()
{
    // 创建文件内存映射，第一个参数传0表示创建一个空的文件映射，若同名映射存在则直接返回句柄
    hMapping = ::CreateFileMapping(0, NULL, PAGE_READWRITE, 0, SHAREDMEMSIZE, SHAREDMEMNAME);
    if (!hMapping)
    {
        _tprintf(_T("failed to create or get file mapping![%d]\n"), GetLastError());
        return -1;
    }
    
    // 将内存映射的一部分(本例是全部)映射到当前进程的地址上
    pSharedMemAddress = MapViewOfFile(hMapping, FILE_MAP_WRITE , 0, 0, SHAREDMEMSIZE );
    if (!pSharedMemAddress)
    {
        _tprintf(_T("failed to get mapping address![%d]\n"), GetLastError());
        CloseHandle(hMapping);
        return -1;
    }

    return 0;
}

// 释放共享内存区
int releaseSharedMemory()
{
    if (pSharedMemAddress)
    {
        UnmapViewOfFile(pSharedMemAddress);
    }

    if (hMapping)
    {
        // 只需关闭句柄即可，当所有句柄都关闭后会自动销毁共享内存区
        CloseHandle(hMapping);
    }
    return 0;
}


int main(int argc, _TCHAR* argv[])
{
    if( 0 > initSharedMemory())
    {
        return -1;
    }
    volatile share_data_t* pdata = reinterpret_cast<share_data_t*>(pSharedMemAddress);
    
    //使用Interlocked API来实现原子（atomic）自增操作，返回自增前的值
    int num = InterlockedIncrement(V(&pdata->numInst));

    if(num > maxInstCount)
    {
        _tprintf(_T("the process count reached max, programe terminated"));
    }else
    {
        _tprintf(_T("current process instance count:%d"), num);

        int input = 0;
        while ('e' != getchar())
        {
            _tprintf(_T("current process instance count:%d"), pdata->numInst);
        }
        
    }

    InterlockedDecrement(V(&pdata->numInst)); //原子(atomic)自减

    releaseSharedMemory();
    return 0;
}

int do_sth()
{
  int ret = 0;

  char* buffer = new char[BUFFER_SIZE];
  XXObject* pObj = new XXObject();
  
  YYObject* pObj2 = pObj->CreateYY(buffer);
  if(!pObj2)
  {
    LOG_WARNING("failed to Create YY");
    delete pObj;
    delete buffer;
    return -1;
  }

  ret = pObj2->work();
  if(ret)
  {
    LOG_WARNING("call YY::work() failed, err:%d", ret);
    delete pObj;
    delete pObj2;
    delete buffer;
    return -1;
  }

  ret = pObj2->work2();
  if(ret)
  {
    LOG_WARNING("call YY::work2() failed, err:%d", ret);
    delete pObj;
    delete pObj2;
    delete buffer;
    return -1;
  }

  return 0;
}

int do_sth()
{
  int ret = 0;

  char* buffer = NULL;
  XXObject* pObj = NULL;
  YYObject* pObj2 = NULL;

  buffer = new char[BUFFER_SIZE];
  pObj = new XXObject();
  
  pObj2 = pObj->CreateYY(buffer);
  if(!pObj2)
  {
    LOG_WARNING("failed to Create YY");
    goto err;
  }

  ret = pObj2->work();
  if(ret)
  {
    LOG_WARNING("call YY::work() failed, err:%d", ret);
    goto err;
  }

  ret = pObj2->work2();
  if(ret)
  {
    LOG_WARNING("call YY::work2() failed, err:%d", ret);
    goto err;
  }

  return 0;

err:
    delete pObj;
    delete pObj2;
    delete buffer;
    return -1;
}

int do_sth()
{
  int ret = 0;

  std::vector<char> buffer;
  buffer.reserve(BUFFER_SIZE);
  std::auto_ptr<XXObject> pObj(new XXObject());
  std::auto_ptr<YYObject> pObj2(pObj->CreateYY(buffer));
  if(!pObj2)
  {
    LOG_WARNING("failed to Create YY");
    return -1;
  }

  ret = pObj2->work();
  if(ret)
  {
    LOG_WARNING("call YY::work() failed, err:%d", ret);
    return -1;
  }

  ret = pObj2->work2();
  if(ret)
  {
    LOG_WARNING("call YY::work2() failed, err:%d", ret);
    return -1;
  }

  return 0;
}

template<typename T>
class RAIIPtr
{
public:
    typedef T element_type;

    RAIIPtr() : m_ptr(NULL){};
    explicit RAIIPtr(T* ptr) : m_ptr(ptr){};
    ~RAIIPtr()
    {
        delete m_ptr;
    }

    T* get() const{ return m_ptr;}
    T& operator * (){ return *m_ptr;}
    T* operator ->() const { return m_ptr; }

    T* release()
    {
        T* p = m_ptr;
        m_ptr = NULL;
        return p;
    }

    void reset(T* ptr)
    {
        if (ptr == m_ptr) { return; }
        delete m_ptr;
        m_ptr = ptr;
    }

private:
    RAIIPtr(const RAIIPtr& v); // 禁止拷贝构造
    RAIIPtr& operator = (const RAIIPtr& v); // 禁止赋值

    T* m_ptr;
};