C / C++ / MFC

Leslie Sanford wrote:

Unfortunately, that means that this:

extern const int BufferSize;

Doesn't work.

extern const int BufferSize;

const int BufferSize = 16384;

Mark Salsbery
Microsoft MVP - Visual C++

Mark Salsbery wrote:

Why not?

// In the SynthToolkit header file...
 
extern int BufferSize;
 
// In another header file...
 
#include "SynthToolkit.h"
 
class SomeClass
{
private:
    buffer[BufferSize];
};

CPallini wrote:

But he didn't it. He declared BufferSize as const.

Leslie Sanford wrote:

I stand by my original point. An integer constant with external linkage can't be used to declare the size of an array at compile time.

CPallini wrote:

You can use it in the source file (there must be one) that defines (assigns) the const variable.
Anyway, on the overall, you're right.

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.
};