ref class A{
public:
	static A^ getInstance(){
		if(INSTANCE==nullptr)
			INSTANCE=gcnew INSTANCE();
		return INSTANCE;
	}

	void destroyInstance(){
		delete INSTANCE;
	}

	...
private:
	int n;
	char **c;
	unsigned char *d;
	String ^str;
	Int32 ^intptr;
	array<String^> ^aS;
	Int32 num;

	A(){
		this->n=0;
		this->c=new char*[10];
		for(int i=0;i<10;i++) this->c[i]=new char[100];
		this->d=new unsigned char[20];
		this->str=gcnew String("A");
		this->intptr=gcnew IntPtr();
		this->aS=gcnew String^[100];
		for(int i=0;i<100;i++) this->aS[i]=gcnew String();
		this->num=1;
	}

	!A(){
		for(int i=0;i<10;i++){
			delete[] this->c;
			this->c=NULL;
		}
		delete[] this->c;
		this->c=NULL;
		delete[] this->d;
		this->d=NULL;
	}

	~A(){
		this->!A();
		delete this->str;
		this->str=nullptr;
		delete this->intptr;
		this->intptr=nullptr;
		for(int i=0;i<100;i++){
			delete this->aS[i];
			this->aS[i]=nullptr;
		}
	}
}

...
bool shouldStop=false;
ManualResetEvent ^mre=gcnew ManualResetEvent(false);
...

void warningListener(){
	while(!stop){
		try{
			ReadFile(...);
			//Hacer algo...
		}catch(ThreadInterruptException ^ie){ 
			mre->WaitOne();
		}
	}
}

#include "StdAfx.h"
#include "SerialPort_WINAPI.h"

/*** Atributos constantes definidos en el .h ***/
const wchar_t *const SerialPort_WINAPI::DEFAULT_PORT_NAME = L"COM6";
static const wchar_t *const DEFAULT_PORT_NAME; //Inicializado en el cpp.
static const DWORD BAUD_RATE = 9600;
static const BYTE STOP_BITS = 1;
static const BYTE PARITY = 0; //0==None
static const BYTE DATA_BITS = 8;
static const DWORD HANDSHAKE = 0x00;

SerialPort_WINAPI::SerialPort_WINAPI(void){

}

SerialPort_WINAPI::~SerialPort_WINAPI(void){

}

SerialPortErr SerialPort_WINAPI::openConnection(){
	port = CreateFile(SerialPort_WINAPI::DEFAULT_PORT_NAME, //\\\\.\\COM4"
		GENERIC_READ | GENERIC_WRITE,
		0,    // exclusive access 
		NULL, // default security attributes 
		OPEN_EXISTING,
		FILE_FLAG_OVERLAPPED,
		NULL
	);
	if (port == INVALID_HANDLE_VALUE)
		return Create_File_Err;

	if (GetCommState(port, &portConfig) == 0){
		closeConnection();
		return Get_Comm_State_Err;
	}
		
	initData();
	if (SetCommState(port, &portConfig) == 0){
		closeConnection();
		return Set_Comm_State_Err;
	}
		
	if (SetCommMask(port, EV_DSR) == 0){ //EV_CTS | EV_DSR
		closeConnection();
		return Set_Comm_Mask_Err; 
	}

	initOverlapped();
	portEvents.hEvent = CreateEvent(
		NULL,   // default security attributes 
		TRUE,   // manual-reset event 
		FALSE,  // not signaled 
		NULL    // no name
	);

	return Exit_Success;
};

void SerialPort_WINAPI::initData(){
	portConfig.BaudRate = BAUD_RATE;
	portConfig.fRtsControl = HANDSHAKE;
	portConfig.Parity = PARITY;
	portConfig.ByteSize = DATA_BITS;
	portConfig.StopBits = STOP_BITS;
};

void SerialPort_WINAPI::initOverlapped(){
	portEvents.Internal = 0;
	portEvents.InternalHigh = 0;
	portEvents.Offset = 0;
	portEvents.OffsetHigh = 0;
};

SerialPortErr SerialPort_WINAPI::closeConnection(){
	SetCommMask(port,0);
	if (CloseHandle(port) == 0)
		return Close_Err;
	return Exit_Success;
};

SerialPortErr SerialPort_WINAPI::read(char *buffer,int length,LPDWORD read){
	if(!ReadFile(this->port,buffer,length,read,&this->portEvents)){
		return Read_Err;
	}
}

SerialPortErr SerialPort_WINAPI::write(char *buffer,int nBytesToWrite,LPDWORD write){
	if(!WriteFile(this->port,buffer,nBytesToWrite,write,&this->portEvents)){
		return Write_Err;
	}
}

int main(){
	SerialPort_WINAPI sp;
	char readBuffer[128];
	DWORD read;
	char writeBuffer[10];
	DWORD write;
	for(int i=0;i<10;i++) writeBuffer[i]='a';

	SerialPortErr err=sp.openConnection();
	if(err!=Exit_Success){
		cout<<"open: "<<(int)err<<endl;
		return -1;
	}else{
		cout<<"Openned..."<<endl;
	}
	
	err=sp.write(writeBuffer,10,&write);
	if(err!=Exit_Success){
		cout<<"write: "<<GetLastError()<<endl;
	}

	err=sp.read(readBuffer,128,&read);
	if(err!=Exit_Success){
		cout<<"read: "<<GetLastError()<<endl;
	}


	err=sp.closeConnection();
	cout<<"close: "<<(int)err<<endl;
	return 0;
}

class A{

private:
  int n;
  char *c;

public:
  A(){
       this->n=0;
       this->c=new char[20];
  }

  ~A(){
       delete[] this->c;
       this->c=NULL;
      //¿delete this->n? <== ¿Hay que hacer esto?
   }
}