Why char pointer is allocated with new

Question

0.00/5 (No votes)

See more:

hi, i constructed my own string class where i use char* str
the below is the piece of code

From below code snippet, In param constructor and copy constructor
cstr = str; //this part of statement works fine.

but even then why i need to allocate memory using new and then strcpy required?
cstr = new char[strlen(str) +1];
strcpy(cstr, str);
both works fine. but why to choose dynamic allocation method?

What I have tried:

C++

class CString
{
private:
	char* cstr;
public:
	CString();
	CString(char* str);
	CString(CString& str);
	~CString();

	operator char*();
	//operator const char*();
	CString operator+(const CString& q)const;
	CString operator=(const CString& q);
};
CString::CString()
{
	cout << "constructor" << endl;
	cstr = 0;
}
CString::CString(char *str)
{
	cout << " param constructor" << endl;
	//cstr = str;// this works fine even then we allocating with new why???
	cstr = new char[strlen(str) +1];
	strcpy(cstr, str);
}
CString::CString(CString& q)
{
	cout << " copy constructor" << endl;
	if (this == &q)
		return;
	cstr = q.cstr;
	//cstr = new char[strlen(q.cstr) + 1];
	//strcpy(cstr, q.cstr);
}
CString::~CString()
{
	//if (cstr)
	//	delete[] cstr;
}
CString::operator char*()
{
	cout << " operatorcahr*" << endl;
	return cstr;
}
//CString::operator const char* ()
//{
//	cout << " const operatorcahr*" << endl;
//	return cstr;
//}
CString CString::operator +(const CString &q) const
{
	cout << "operator +*" << endl;
	CString s;
	s.cstr = new char[strlen(cstr) + strlen(q.cstr) + 1];
	strcpy(s.cstr, cstr);
	strcat(s.cstr, q.cstr);
	return s;
}
CString CString::operator =(const CString &q)
{
	cout << "operator =" << endl;
	if (this != &q)
	{
		//if (cstr)
			//delete[] cstr;
		cstr = new char[strlen(q.cstr) + 1];
		strcpy(cstr, q.cstr);
	}
	return *this;
}

int _tmain(int argc, _TCHAR* argv[])
{
	CString a = CString("Hello") + CString(" World");
	cout << a << endl;
	getchar();
	return 0;
}

Posted 29-Nov-16 0:21am

Member 11732139

Updated 29-Nov-16 1:05am

Jochen Arndt

v2

Add a Solution

Comments

Philippe Mori 29-Nov-16 10:17am

Although writing a string class is a good exercise, one should usually use standard string class in production code as the standard class was coded by experts who have a better understanding of pitfalls like those.

Philippe Mori 29-Nov-16 10:24am

One example where your code would probably fails is CString a = CString() + CString(" World");. That is if you replace the first constructor call so that the default constructor is used.

Also operator= should return a reference.

2 solutions

Solution 2

With a string you have some memory where it is actually stored and you have a pointer to this memory which references the string. If you want to create a copy of the string you must copy the memory which requires allocating new memory for it.

There are also some errors and possible optimisations in your code.

For example you should delete the old memory when allocating a new block and when the object is destroyed:

CString CString::operator =(const CString &q)
{
    cout << "operator =" << endl;
    if (this != &q)
    {
        // No need to check if cstr is NULL.
        // delete does nothing in this case.
        delete[] cstr;
        // But check here if q.cstr is NULL!
        if (q.cstr)
        {
            cstr = new char[strlen(q.cstr) + 1];
            strcpy(cstr, q.cstr);
        }
        // String is empty now
        else
            cstr = 0;
    }
    return *this;
}

CString::~CString()
{
    delete[] cstr;
}

Once you have implemented the assignment operator, it can be used by other functions:

C++

CString::CString(const CString& q)
{
    cout << " copy constructor" << endl;
    *this = q;
}

Knowing this it might be better to have a CString::CString(const char *s) assignment operator instead because that can be used for multiple copy constructors.

Posted 29-Nov-16 1:05am

Jochen Arndt

Updated 29-Nov-16 1:07am

v2

Comments

Member 11732139 29-Nov-16 7:36am

did you mean i did shallow copy ... for deep copy you need to allocate memory ..
is that my understanding correct!!

Jochen Arndt 29-Nov-16 8:04am

Yes.
When a class contains allocated memory you need deep copy (allocating and copy the content).
Shallow copy is copying the content of the members which would be coyping the char* pointer in your case.

[no name] 29-Nov-16 8:07am

Yes, absolutely correct. Since a shallow copy would break the encapsulation of your class, you must do a deep copy.

Philippe Mori 29-Nov-16 10:14am

Generally, it is better to implement operator= using the copy constructor and swap idiom as it make it easier to write exception safe code.

Also, in your case, the copy constructor might fails while calling the assignment operator since cstr has not yet been initialized.

Member 11732139 30-Nov-16 0:50am

Thank you ... found some improvement in my understanding.
am still not clear why CString::CString(const char *s) is required...!!!

Jochen Arndt 30-Nov-16 2:54am

What is unclear, the const or the constructor with char*?

Both is not required.

But it makes sense to have a string class with a char* constructor.

The const tells the compiler (and the developer that is using the function), that the function will not alter the passed string. It should always be used when a variable is not changed.

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

hairy_hats · Accepted Answer · 2016-11-29T00:42:00

Solution 1

If you use cstr = str; then your class just contains a pointer to the external initialisation string, which could be modified outside of your class. If you take a copy of it, you have complete control over your class's internal string.

Posted 29-Nov-16 0:42am

hairy_hats

Comments

Member 11732139 29-Nov-16 7:33am

Hi, thank you the reply.
can you give more detail with example that what do mean by "which could be modified outside of your class" from your ques

did you mean copyconstructor should have const as param?
CString::CString(const CString& q)

hairy_hats 29-Nov-16 7:47am

Suppose you had:

char [] hello = "Hello, world!";

CString string(hello); // string contains "Hello, World!"

strcpy(hello, "Goodbye!");

If you use cstr=str; then string now contains "Goodbye!" even though you changed hello. If you allocate your own memory and copy the initialisation text, then your class's internal text doesn't change.

Philippe Mori 29-Nov-16 10:10am

Even worst would be data on the stack or that are otherwise deleted while the string still reference that copy...