C / C++ / MFC

Member 754960 wrote:

AFAIK, the only reason for this style is a compiler limitation. The language allows a class constant definition but the MSVC compiler (for one) doesn't handle it.

Member 754960 wrote:

I seem to recall that using enums for constants is somewhat frowned upon

Member 754960 wrote:

common practice though.

class A
{
	static const int MAXBUFFERLEN = 1024;
	char szBuffer[MAXBUFFERLEN];
public:
	A() {}
	~A() {}
};

enum WeekDays
{
	Monday = 0,
	Tuesday = 1,
	Wednesday = 2,
	Thursday = 3,
	Friday = 4,
	Saturday = 5,
	Sunday = 6,
	//NumberofWeekDays = Sunday + 1	// error prone
	NumberofWeekDays = 7	// explicit definition
};

int Workdays[5];

void f()
{
	int i = Workdays[Monday];	// error ??? : integer index expected
	i = Monday;			// error ??? integer value expected	
}

void f(WeekDays aDay) {}

void g()
{
	f(WeekDays(24));	// invalid type coersion
}

class ToolKit
{
  enum State {
    st_Idle,
    st_Init,
    st_Tx,
    st_Rx,
    st_Swap,
    st_More // Error.
  };
  State  m_State;
protected:
  bool ThreadProcedure() {
    switch(m_State) {
    case st_Init:
      // ...
      break;
    }
    return true;
  }
public:
  bool OnButtonClickInitialize() {
    if(Busy()) {
      return Reject();
    }
    return NewTask(st_Init);
  }
};

Member 754960 wrote:

a compiler limitation. The language allows a class constant definition but the MSVC compiler (for one) doesn't handle it.

class ToolKit
{
public:
  const int n = 10; // Error C2864. (VC2005)
};

class ToolKit
{
public:
  ToolKit() : n(10) { }
  const int n; // Pass! (VC2005)
};

class ToolKit
{
  static const int a = 5; // Supported since VC.NET (7.0)
};

class ToolKit
{
  const int a = 5; // Not yet in VC2005.
};

_NielsB wrote:

// buffAB is the only thing we want ... how to clean up the rest?

char * pB = malloc(2);
pB[0]='b';
pB[1]='b';
/* or *pb='b'; *(pb+1)='b'; */
/* or memset(b, (int)'b', 2); */
char * pA = malloc(1);
pA[0]='a'; /* same options b has */
char * PAB = malloc(3);
memcpy(pAB, pA, 1 );
memcpy(pAB+1, pB, 2);
free(pA);
free(pB);

char *p=malloc(10);
if ( ! p )
{
  /* handle error */
}
/* allocation was fine, go on

<br />
// buffA<br />
int n_A = 30; <br />
char* p_buffA = new char[n_A];<br />
memset(p_buffA, (int)'a', n_A);<br />
<br />
// buffB<br />
int n_B = 50;<br />
char* p_buffB = new char[n_B];<br />
memset(p_buffB, (int)'b', n_B);<br />
	<br />
// append buffB to buffA, use temp buffAB<br />
int n_AB = n_A + n_B;<br />
char* p_buffAB = new char[n_AB];<br />
	<br />
// cpy<br />
memcpy(p_buffAB, p_buffA, n_A); // copy buffA to buffAB<br />
memcpy(p_buffAB+n_A, p_buffB, n_B); // copy buffB to buffAB<br />
<br />
// buffA and buffB are no longer neaded -> delete<br />
delete [] p_buffA;<br />
delete [] p_buffB;<br />
<br />
// set buffA to buffAB<br />
p_buffA = p_buffAB;<br />
n_A = n_AB;<br />
<br />

char* p_buffA = new char[n_A];
if ( !p_buffA )
{
  // handle error
}
// go on with program
...

// buffA
int n_A = 30; 
char* p_buffA = (char*) malloc(n_A);
memset(p_buffA, (int)'a', n_A);

// buffB
int n_B = 50;
char* p_buffB = (char*) malloc(n_B);
memset(p_buffB, (int)'b', n_B);

// append buffB to buffA, without use temporary
char* p_buffA = realloc[p_BuffA, n_A + n_B];

// cpy
memcpy(p_buffA + n_A, p_buffB, n_B); // copy buffB to new buffA

// buffB is no longer neaded, delete
free(p_buffB);

if (rsltDoc = IHTMLDocument2Ptr(brwsr->GetDocument())) {
       HRESULT hr = rsltDoc->get_body(&body);
   if (!FAILED(hr)) {
         BSTR bstr_b;
     hr = body->get_innerText(&bstr_b);
     if (!FAILED(hr)) {
           char* szBody = ConvertBSTRToString(bstr_b);
       if (!strstr(szBody,szNotFound)) {
         pf_fmt(szSrch);
         fprintf(f,"%s\n\n",szSrch);
         printf("%s\n\n",szSrch);
         bMatch = TRUE;
       }
       delete [] szBody;
       SysFreeString(bstr_b);
     }
   }
     }

tibiz wrote:

Or need to change registry values?