char* dynamic strings - the right way

[drj0nson]

What is the right way of creating a string/char array and assigning to
a char* which is then used in a function call. Thought it would be
quite nice to avoid a memory leakage /core dump.

1 Header with char* x

2 Class includes header

3 In Class member function I want to :
a)conditionally create a string ie populate x
b)pass (populated) x on as a function parameter.

What is the right way of doing this for :
i) assigning string variable
ii) assigning a literal.

i) Since it's a conditional create I guess it is not a good idea to use
malloc or new.

ii) Is it ok to just have x = "some string";

[drj0nson]

John Harrison wrote:

dr******@gmail. com wrote:

I do not know the correct way of doing this - that is why I am posting
here!

1. You have a char *
2. You need to go off and populate this with a string or char array but
you do not know the size of the string., so....
3. string seems to be 'the' way of doing this but
a) c_str() returns a const and needs casting using char*
b) although the c_str() casting works and it is possible to print
the string out later - is this a case of something that will work
but not always?

You need to allocate memory

string s = "qwerty";
char* ptr = new char[s.size() + 1];
strcpy(ptr, s.c_str());
...
// sometime later when you are done
delete[] ptr;

It's because of this mess (particularly the need to delete[]) that you
should use strings instead of char, if you possibly can.

john

thanks John, I was hoping there was a better way.
Maybe that the string for object string s would remain
while it had a reference to it and remove it once that
reference is removed - but maybe thats java.

So my program above becomes:

void f2(string &s)
{
s="qwerty";
}
void f1(myStruct &ms)
{
string s;

f2(s);
// Error 203: # Cannot assign 'char *' with 'const char *'.
//ms.cp = s.c_str();

ms.cp = new char[s.size() + 1];
strcpy(ptr, s.c_str());

// and not ms.cp = (char*)s.c_str( );
}
int main () {
myStruct mystruct;

f1(mystruct);
cout << mystruct.cp << endl;
delete [] ms.cp;

return 0;
}

[werasm]

> int main () {

myStruct mystruct;

f1(mystruct);
cout << mystruct.cp << endl;
delete [] ms.cp;

return 0;
}

To find out whether this will work, I have to see what myStruct looks
like. Looks bad, though. Show us <myStruct> definition, then I'll
comment.

Regards,

Werner

[drj0nson]

werasm wrote:

int main () {
myStruct mystruct;

f1(mystruct);
cout << mystruct.cp << endl;
delete [] ms.cp;

return 0;
}

To find out whether this will work, I have to see what myStruct looks
like. Looks bad, though. Show us <myStruct> definition, then I'll
comment.

Regards,

Werner

Whoops sorry,

typedef struct {
char *cp;
} myStruct ;

[werasm]

dr******@gmail. com wrote:

Whoops sorry,

typedef struct {
char *cp;
} myStruct ;

I've looked at your example. It does not compile, firstly - where is
ptr declared in f1 (I'll assume you've meant ms.cp)? Also, the strcpy
omits copying the NULL terminator. This would mean streaming the
NON-terminated string to std::cout would envoke undefined behaviour, if
I'm not mistaken. All of this could have been achieved using:

int main()
{
std::cout << qwerty << std::endl;
return 0;
}

I don't see the point. Also, myStruct does not overload a copy
constructor/assignment operator/destructor. In general, the code is
bad. The only thing you are doing right, is that you call operator
delete[] when creating with operator new[] - good.

W

[drj0nson]

Thank you for looking at the code and apologies for the compile error.
Here is the compiled version:

typedef struct {
char *cp;
} myStruct ;

void f2(string &s)
{
s="qwerty";

}

void f1(myStruct &ms)
{
string s;

f2(s);

ms.cp = new char[s.size() + 1];
strcpy(ms.cp, s.c_str());
ms.cp[s.size()]='\0';
}

int main () {
myStruct mystruct;

f1(mystruct);
cout << mystruct.cp << endl;
delete [] mystruct.cp;

return 0;
}

Please bear in mind I have created a simplified example to illustrate a
problem. The premise is having to deal with populating existing chars :
a one line cout statement isn't really the answer.

[werasm]

dr******@gmail. com wrote:

Thank you for looking at the code and apologies for the compile error.
Here is the compiled version:

typedef struct {
char *cp;
} myStruct ;
In c++ the typedef is redundant, therefore ...

struct myStruct
{
char* cp;
};
.... would have sufficed.

void f2(string &s)
{
s="qwerty";

}
Even for you example, this (above) is unecessary.

void f1(myStruct &ms)
{
string s;

f2(s);

This could be:
std::string s( "qwerty" );

In general, it is good to qualify the std items explicitly.
ms.cp = new char[s.size() + 1]; Yes, this is how you allocate memory for the array. The size allocated
is correct as you require provision for a NULL terminator. s.size does
return the size of string excluding NULL terminator.
strcpy(ms.cp, s.c_str());
I would have used strncpy (or char_traits::co py) over here (actually I
would use strings :-) ).

strncpy( ms.cp, s.c_str(), s.size() )[s.size()] = '\0';

Note strncpy actually returns the destination string, therefore you
could use above syntax to terminate.
int main () { I would not have made char* part of struct.
myStruct mystruct;
char* myChar;

f1(myChar);

f1 then has signature <char*&>. IMO this still does not convey the
intent of the function, and it does not indicate to the receiver of
char* that he is required to delete it. It is less work and has the
same effect as your example though.

Therefore:

void f1( char*& out )
{
std::string qstr( "qwerty" );
const unsigned outSz( qstr.size()+1 );

out = new char[ outSz];
strncpy( out, qstr.c_str(), outSz-1 )[outSz];
}

int main()
{
char* myChar( 0 );
f1( myChar );
if( myChar )
{
std::cout << myChar << std::endl;
delete [] myChar;
}
return 0;
}

Also note that deleting a NULL ptr is valid, but sending NULL ptr to
std::cout may not be.

Kind regards,

W

[werasm]

werasm wrote:

dr******@gmail. com wrote:

Thank you for looking at the code and apologies for the compile error.
Here is the compiled version:

typedef struct {
char *cp;
} myStruct ;
In c++ the typedef is redundant, therefore ...

struct myStruct
{
char* cp;
};
... would have sufficed.

void f2(string &s)
{
s="qwerty";

}

Even for you example, this (above) is unecessary.

void f1(myStruct &ms)
{
string s;

f2(s);

This could be:
std::string s( "qwerty" );

In general, it is good to qualify the std items explicitly.

ms.cp = new char[s.size() + 1];

Yes, this is how you allocate memory for the array. The size allocated
is correct as you require provision for a NULL terminator. s.size does
return the size of string excluding NULL terminator.

strcpy(ms.cp, s.c_str());

I would have used strncpy (or char_traits::co py) over here (actually I
would use strings :-) ).

strncpy( ms.cp, s.c_str(), s.size() )[s.size()] = '\0';

Note strncpy actually returns the destination string, therefore you
could use above syntax to terminate.

Actually, this is not necessary in this case, as the source is
guaranteed to be terminated, and strncpy reads until it finds a
terminator, then pads the rest therefore the above statement can
become:

strncpy( ms.cp, s.c_str(), s.size()+1 );

This will ensure ms.cp is terminated :-).

int main () { I would not have made char* part of struct.

myStruct mystruct;

char* myChar;

f1(myChar);

f1 then has signature <char*&>. IMO this still does not convey the
intent of the function, and it does not indicate to the receiver of
char* that he is required to delete it. It is less work and has the
same effect as your example though.

Therefore:

void f1( char*& out )
{
std::string qstr( "qwerty" );
const unsigned outSz( qstr.size()+1 );

out = new char[ outSz];
strncpy( out, qstr.c_str(), outSz-1 )[outSz];

Note that above statement should actually be...

strncpy( out, qstr.c_str(), outSz );

.... for reasons previously mentioned.
}

int main()
{
char* myChar( 0 );
f1( myChar );
if( myChar )
{
std::cout << myChar << std::endl;
delete [] myChar;
}
return 0;
}

Also note that deleting a NULL ptr is valid, but sending NULL ptr to
std::cout may not be.

Kind regards,

W