dougm@rhea.rice.edu (Doug Moore) (09/17/89)
Here are two situations that I, as a newcomer to C++, can't figure out how to handle in the C++ way, only in a kludgey way: 1. How do you declare and initialize a private constant value local to a class? In an implementation of Stack, for example, I want the constant MAX_STACK_SIZE to have some hidden value. In C, I would #define it. In C++, I can do no better than make a static const private member, but then it takes up space. I could have many such constants, not properly groupable into an enum type, and I would have to have runtime storage for all of them. Is there a better way? 2. How do you initialize some data structures for a class? For creating a new object of the class, I know how. Consider, for example, a Stack class, where a static array of fixed size is to hold all the items in all the Stacks. A free space stack must be initialized before the first item is pushed onto a stack. The only way I know to set up the necessary data structure is to have a flag initialized to TRUE that triggers the free-list initialization on the creation of the first Stack, after which the flag is reset. Also pretty ugly. Is there a C++-ish way to do this? Doug Moore (dougm@rice.edu)
jima@hplsla.HP.COM (Jim Adcock) (09/19/89)
// re first question:
// Unfortunately, your reasonable request still does not seem to be supported
// by C++ compilers. You should be able to meet your needs by declaring
// a constant static class member, and defining an initial value for it.
// But present compilers will not allow you to give it an initial value until
// after the class declaration, and will not accept a class declaration with
// an array size whose bounds are not known at class declaration time.
#include <stdio.h>
typedef char* cstring;
// What today's C++ compilers should be willing to accept, but won't:
//
// class cstringstack;
//
// static const int cstringstack::maxStackSize = 100; ?!?!?!?
//
// class cstringstack
// {
// static const int maxStackSize; ?!?!?!?
// cstring element[maxStackSize];
// int top;
// public:
// cstringstack(): top(0) {}
// void push(const cstring s){element[top++] = s;}
// cstring pop(){return element[--top];}
// cstringstack& popprint(){printf("%s\n",this->pop()); return *this;}
// };
// Or maybe they should accept:
//
// class cstringstack
// {
// static const int maxStackSize;
// cstring element[maxStackSize]; ?!?!?!?
// int top;
// public:
// cstringstack(): top(0) {}
// void push(const cstring s){element[top++] = s;}
// cstring pop(){return element[--top];}
// cstringstack& popprint(){printf("%s\n",this->pop()); return *this;}
// };
//
// static const int cstringstack::maxStackSize = 100; ?!?!?!?
// the best you can do with today's compilers:
static const int cstringstack__maxStackSize = 100;
class cstringstack
{
cstring element[cstringstack__maxStackSize];
int top;
public:
cstringstack(): top(0) {}
void push(const cstring s){element[top++] = s;}
cstring pop(){return element[--top];}
cstringstack& popprint(){printf("%s\n",this->pop()); return *this;}
};
void main()
{
cstringstack stk;
stk.push("hi mom");
stk.push("hello dad");
stk.push("bye world");
stk.popprint().popprint().popprint();
}jima@hplsla.HP.COM (Jim Adcock) (09/19/89)
//re your second question:
#include <stdio.h>
typedef char* cstring;
class cstringStack;
static const int cstringStack__maxCstringSpace = 10000;
class cstringStack
{
static cstring cstringSpace[cstringStack__maxCstringSpace];
static int cstringSpaceUsed;
cstring* element;
int top;
public:
cstringStack(const int stacksize):
top(0), element(&cstringSpace[cstringSpaceUsed])
{cstringSpaceUsed += stacksize; }
void push(const cstring s){element[top++] = s;}
cstring pop(){return element[--top];}
cstringStack& popprint(){printf("%s\n",this->pop()); return *this;}
};
cstring cstringStack::cstringSpace[10000] = {0};
int cstringStack::cstringSpaceUsed = 0;
void main()
{
cstringStack stk1(30);
stk1.push("hi mom");
stk1.push("hello dad");
stk1.push("bye world");
stk1.popprint().popprint().popprint();
cstringStack stk2(40);
stk2.push("hi mom too");
stk2.push("hello dad too");
stk2.push("bye world too");
stk2.popprint().popprint().popprint();
}psrc@pegasus.ATT.COM (Paul S. R. Chisholm) (09/20/89)
<Excuse me if you see this twice; I left out the colon after "private".> In article <DOUGM.89Sep17031020@rhea.rice.edu>, dougm@rhea.rice.edu (Doug Moore) writes: > How do you declare and initialize a private constant value local > to a class? In an implementation of Stack, for example, I want the > constant MAX_STACK_SIZE to have some hidden value. In C, I would > #define it. In C++, I can do no better than make a static const > private member, but then it takes up space. I could have many such > constants, not properly groupable into an enum type, and I would have > to have runtime storage for all of them. Is there a better way? And the static private member function can't be initialized in the header file (at least not in 1.2.3), and can't be used to set an array bound. This question came up in a C++ mailing list that a friend of mine is on (and I have *no* information about, so please don't ask). Four people came up with the same answer. You're going to hate it: private: enum { MAX_STACK_SIZE = 1024 }; That is, an unnamed enum type with one initialized value. Sometimes I miss Pascal, y'know? > Doug Moore (dougm@rice.edu) Paul S. R. Chisholm, AT&T Bell Laboratories att!pegasus!psrc, psrc@pegasus.att.com, AT&T Mail !psrchisholm I'm not speaking for the company, I'm just speaking my mind.