C / C++ / MFC

Member 754960 wrote:

How was this conflict avoided up 'til now?
Why is it coming up now?

const int BufferSize = 16384;

void f()
{
char buf[Buffersize];

//...
}

class SynthToolKit
{
public:
  enum Size {
    enBufMax = 1684,
    enBufMin = 12
  };
};
// SomeOther.cpp
bool OtherKit::Test()
{
  p = new UCHAR[SynthToolKit::enBufMax];
  // ...
}

Maxwell Chen wrote:

I prefer enum for any class scope integer constants.

Leslie Sanford wrote:

don't know if this is considered bad style

class ToolKit
{
public:
  enum Size {
    enBufMin = 12,
    enBufMax = 1024
  };
  enum Pos { // enum to group.
    enTop,
    enRight,
    enLeft
    enBottom
  };
  bool Alloc(Size val) { // enum as type.
    // ...
    return true;
  }
};

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);