Problem with class type in static instance of struct

[Robert Sturzenegger]

We had a strange problem in a large project with the use of a string class
in a static instance of a struct.
I managed to reproduce the exactly same problem in a very short program (see
below).
When the constant SHORT_STRING_SI ZE_LIMIT is set to 0, the program works as
expected and outputs the string "+". When it is set to 7, it outputs garbage
(a part of a non-initialized storage area).
We are using gcc version 3.3 on SuSE Linux.

#include <iostream>
using namespace std;

const unsigned int SHORT_STRING_SI ZE_LIMIT = 0;
//const unsigned int SHORT_STRING_SI ZE_LIMIT = 7;
// String
class ----------------------------------------------------------------
class String
{
public:
String(const char* s);
friend ostream& operator<< (ostream& os, const String& sStr);

private:
char* allocate();

char m_cShortString[SHORT_STRING_SI ZE_LIMIT + 1];
unsigned int m_uiCapa;
unsigned int m_uiSize;
char* m_p;
};

String::String( const char* s)
{
if (s == NULL) {
m_p = allocate();
m_p[0] = '\0';
return;
}
m_uiSize = strlen(s);
m_p = allocate();
strcpy(m_p, s);
}

char* String::allocat e()
{
char* p;
if (m_uiSize <= SHORT_STRING_SI ZE_LIMIT) {
m_uiCapa = SHORT_STRING_SI ZE_LIMIT;
p = m_cShortString;
} else {
m_uiCapa = m_uiSize;
p = new char[m_uiCapa + 1];
}
return p;
}

ostream& operator<< (ostream& os, const String& sStr)
{
os << sStr.m_p;
return os;
}
// End of String
class ---------------------------------------------------------
struct Operators
{
String m_sOperator;
};
static Operators operators= {"+"};
int main()
{
cout << operators.m_sOp erator << endl;
}

[Victor Bazarov]

Robert Sturzenegger wrote:

We had a strange problem in a large project with the use of a string class
in a static instance of a struct.
I managed to reproduce the exactly same problem in a very short program (see
below).
When the constant SHORT_STRING_SI ZE_LIMIT is set to 0, the program works as
expected and outputs the string "+". When it is set to 7, it outputs garbage
(a part of a non-initialized storage area).
We are using gcc version 3.3 on SuSE Linux.
Well, looks like a bug in the compiler. Did you use the debugger to find
out what's wrong?
[...]

V

[Alan]

"Robert Sturzenegger" <no****@nowhere .net> wrote in message news:cq******** **@news.hispeed .ch...

We had a strange problem in a large project with the use of a string class
in a static instance of a struct.
I managed to reproduce the exactly same problem in a very short program (see
below).
When the constant SHORT_STRING_SI ZE_LIMIT is set to 0, the program works as
expected and outputs the string "+". When it is set to 7, it outputs garbage
(a part of a non-initialized storage area).
We are using gcc version 3.3 on SuSE Linux.

#include <iostream>
using namespace std;

const unsigned int SHORT_STRING_SI ZE_LIMIT = 0;
file://const unsigned int SHORT_STRING_SI ZE_LIMIT = 7;
// String
class ----------------------------------------------------------------
class String
{
public:
String(const char* s);
friend ostream& operator<< (ostream& os, const String& sStr);

private:
char* allocate();

char m_cShortString[SHORT_STRING_SI ZE_LIMIT + 1];
unsigned int m_uiCapa;
unsigned int m_uiSize;
char* m_p;
};

String::String( const char* s)
{
if (s == NULL) {
m_p = allocate();
m_p[0] = '\0';
return;
}
m_uiSize = strlen(s);
m_p = allocate();
strcpy(m_p, s);
}

char* String::allocat e()
{
char* p;
if (m_uiSize <= SHORT_STRING_SI ZE_LIMIT) {
m_uiCapa = SHORT_STRING_SI ZE_LIMIT;
p = m_cShortString;
} else {
m_uiCapa = m_uiSize;
p = new char[m_uiCapa + 1];
}
return p;
}

ostream& operator<< (ostream& os, const String& sStr)
{
os << sStr.m_p;
return os;
}
// End of String
class ---------------------------------------------------------
struct Operators
{
String m_sOperator;
};
static Operators operators= {"+"};
int main()
{
cout << operators.m_sOp erator << endl;
}

I had no problems with this program using
DigitalMars (have purchased CD) in Win2K
Pro SP4 - in both cases the output is "+"

Alan

[jd]

Le Mon, 27 Dec 2004 17:39:24 +0100, Robert Sturzenegger a écrit*:

We had a strange problem in a large project with the use of a string class
in a static instance of a struct.
I managed to reproduce the exactly same problem in a very short program (see
below).
When the constant SHORT_STRING_SI ZE_LIMIT is set to 0, the program works as
expected and outputs the string "+". When it is set to 7, it outputs garbage
(a part of a non-initialized storage area).
We are using gcc version 3.3 on SuSE Linux.

#include <iostream>
using namespace std;

const unsigned int SHORT_STRING_SI ZE_LIMIT = 0;
//const unsigned int SHORT_STRING_SI ZE_LIMIT = 7;
// String
class ----------------------------------------------------------------
class String
{
public:
String(const char* s);
friend ostream& operator<< (ostream& os, const String& sStr);

private:
char* allocate();

char m_cShortString[SHORT_STRING_SI ZE_LIMIT + 1];
unsigned int m_uiCapa;
unsigned int m_uiSize;
char* m_p;
};

String::String( const char* s)
{
if (s == NULL) {
m_p = allocate();
m_p[0] = '\0';
return;
}
m_uiSize = strlen(s);
m_p = allocate();
strcpy(m_p, s);
}

char* String::allocat e()
{
char* p;
if (m_uiSize <= SHORT_STRING_SI ZE_LIMIT) {
m_uiCapa = SHORT_STRING_SI ZE_LIMIT;
p = m_cShortString;
} else {
m_uiCapa = m_uiSize;
p = new char[m_uiCapa + 1];
}
return p;
}

ostream& operator<< (ostream& os, const String& sStr)
{
os << sStr.m_p;
return os;
}
// End of String
class ---------------------------------------------------------
struct Operators
{
String m_sOperator;
};
static Operators operators= {"+"};
int main()
{
cout << operators.m_sOp erator << endl;
}

This doesn't look a compiler error for me.
Your Operators struct simply doesn't use the constructors you have
providen for your String class.

[Ron Natalie]

Robert Sturzenegger wrote:

We had a strange problem in a large project with the use of a string class
in a static instance of a struct.
I managed to reproduce the exactly same problem in a very short program (see
below).
When the constant SHORT_STRING_SI ZE_LIMIT is set to 0, the program works as

Your class needs a copy constructor (and a assignment operator and a destructor,
and perhaps even a default constructor).

The problem is that when the limit is set to zero, the implicitly defined
copy constructor copies the pointer but since it points to memory you never
free, the thing works OK. In your case where you have the small string
support, the pointer is copied, but it points to the array of a temporary
object whose lifetime expires (and obviously gets written over).

[Muk]

strcpy(m_p, s);

Before you do this make sure the src string s is null terminated (\0).
In your case it looks like it is not ("+"). Now when
SHORT_STRING_SI ZE_LIMIT = 7, you are copying into char
m_cShortString[8]; Since the dest array m_cShortString may not have \0
at each index, the string is basically not null terminated. This may
cause os << sStr.m_p to print vague results since it does not know the
end of the array (no \0 at end). Make sure all your arrays and strings
are null terminated, especially when using C style functions like
strcpy. When SHORT_STRING_SI ZE_LIMIT = 0 you are creating new
allocation using new char[m_uiCapa + 1] and it looks like the resultant
memory had nulls in it and hence it worked.

[Victor Bazarov]

"Muk" <rs******@hotma il.com> wrote...

strcpy(m_p, s);

Before you do this make sure the src string s is null terminated (\0).
In your case it looks like it is not ("+"). [...]

Every string literal is null-terminated, see 2.13.4p4.

[Robert Sturzenegger]

"Ron Natalie" <ro*@sensor.com > wrote in message
news:41******** *************** @news.newshosti ng.com...

Robert Sturzenegger wrote:

We had a strange problem in a large project with the use of a string
class
in a static instance of a struct.
I managed to reproduce the exactly same problem in a very short program
(see
below).
When the constant SHORT_STRING_SI ZE_LIMIT is set to 0, the program works
as

Your class needs a copy constructor (and a assignment operator and a
destructor,
and perhaps even a default constructor).

The problem is that when the limit is set to zero, the implicitly defined
copy constructor copies the pointer but since it points to memory you
never
free, the thing works OK. In your case where you have the small string
support, the pointer is copied, but it points to the array of a temporary
object whose lifetime expires (and obviously gets written over).

What I posted, is only a small extract of the class. As a matter of course
the class does have a default ctor, several other ctors, a copy ctor and a
dtor. But these do not affect the behaviour in question and that's why I
leaved them out.

[Robert Sturzenegger]

"jd" <zi******@free. fr> schrieb im Newsbeitrag
news:pa******** *************** *****@free.fr.. .

Le Mon, 27 Dec 2004 17:39:24 +0100, Robert Sturzenegger a écrit :

We had a strange problem in a large project with the use of a string class in a static instance of a struct.
I managed to reproduce the exactly same problem in a very short program (see below).
When the constant SHORT_STRING_SI ZE_LIMIT is set to 0, the program works as expected and outputs the string "+". When it is set to 7, it outputs garbage (a part of a non-initialized storage area).
We are using gcc version 3.3 on SuSE Linux.

#include <iostream>
using namespace std;

const unsigned int SHORT_STRING_SI ZE_LIMIT = 0;
//const unsigned int SHORT_STRING_SI ZE_LIMIT = 7;
// String
class ----------------------------------------------------------------
class String
{
public:
String(const char* s);
friend ostream& operator<< (ostream& os, const String& sStr);

private:
char* allocate();

char m_cShortString[SHORT_STRING_SI ZE_LIMIT + 1];
unsigned int m_uiCapa;
unsigned int m_uiSize;
char* m_p;
};

String::String( const char* s)
{
if (s == NULL) {
m_p = allocate();
m_p[0] = '\0';
return;
}
m_uiSize = strlen(s);
m_p = allocate();
strcpy(m_p, s);
}

char* String::allocat e()
{
char* p;
if (m_uiSize <= SHORT_STRING_SI ZE_LIMIT) {
m_uiCapa = SHORT_STRING_SI ZE_LIMIT;
p = m_cShortString;
} else {
m_uiCapa = m_uiSize;
p = new char[m_uiCapa + 1];
}
return p;
}

ostream& operator<< (ostream& os, const String& sStr)
{
os << sStr.m_p;
return os;
}
// End of String
class ---------------------------------------------------------
struct Operators
{
String m_sOperator;
};
static Operators operators= {"+"};
int main()
{
cout << operators.m_sOp erator << endl;
}

This doesn't look a compiler error for me.
Your Operators struct simply doesn't use the constructors you have
providen for your String class.

Yes, it does! I also tried with cout in the ctor. The ctor is run in both
cases.

[Ron Natalie]

Robert Sturzenegger wrote:

What I posted, is only a small extract of the class. As a matter of course
the class does have a default ctor, several other ctors, a copy ctor and a
dtor. But these do not affect the behaviour in question and that's why I
leaved them out.

Perhaps you should put them back in, because it sure as hell makes the
example WRONG without them.

What does your copy constructor look like?