如何在一个类中初始化一个char指针？

Question

I have a confusion while dealing with char pointers. Please have a look at following code:

class Person
{
    char* pname;
public:
    Person(char* name)
    {
        //I want to initialize 'pname' with the person's name. So, I am trying to
        //achieve the same with different scenario's

        //Case I:   
        strcpy(pname, name); // As expected, system crash.

        //Case II: 
        // suppose the input is "ABCD",  so trying to create 4+1 char space
        // 1st 4 for holding ABCD and 1 for '\0'.
        pname = (char*) malloc(sizeof(char) * (strlen(name)+1) );
        strcpy(pname, name);

        // Case III: 
        pname = (char*) malloc(sizeof(char));
        strcpy(pname, name);
    }

    void display()
    {
        cout<<pname<<endl;
    }
};

void main()
{
    Person obj("ABCD");
    obj.display(); 
}

For Case I: As expected, system crash.

Output for Case II:

ABCD

Output for Case III:

ABCD

So, I am not sure why Case II & III are producing the same output !!!!..... How I should initialize a char pointer in a class?

Answer 1

The third case invokes Undefined Behavior and so anything might happen in that case.
You are writing beyond the bounds of allocated memory in this case which may or maynot crash but is a UB.

How to do this the right way in C++?
By not using char * at all!
Just simply use std::string .

Note that std::string provides you with c_str() function which gets you the underlying character string. Unless, You are bothered about passing ownership of a char * to a c-style api you should always use std::string in c++.

Answer 2

The third option is also wrong as you haven't allocated enough memory for it. You're trying to copy a string of size 5 to a buffer of size 1, which means the data after pname[1] are incorrectly overwritten and gone..

If you're lucky, you may see a runtime error such as memory access violation, or you won't see anything but the data behind it is corrupted, eg, your bank account, and you never know about it until..

The correct way to go is to always allocate enough memory to copy to. A better way in C++ is to use std::string , as Als points out, because it'll free you from manual management of memory (allocation, growing, deallocation, etc).

Eg,

class Person
{
    std::string pname;
public:
    Person(char* name)
    {
        pname = name;
    }

    void display()
    {
        cout << pname << endl;
    }
};

void main()
{
    Person obj("ABCD");
    obj.display(); 
}

Answer 3

You have to allocate memory for your member variable pname , however, I don't know why you want to use a char* when you can just use a string :

std::string pname;

//...

pname = std::string(name);

If there is a good reason why you must use a char* , then do something of the sort:

// initialize the pname
pname = new char[strlen(name)];

// copy the pname
strcpy(pname, name);

The reason why you don't need to allocate an extra space at the end of the string for null -termination is because using the double quotes "blah" automatically produces a null -terminated string.

Answer 4

If you are into C++ business, then it's time to dump char pointers on behalf of STL string:

#include <string>

class Person
{
    std::string the_name;
public:
    Person(std::string name) : the_name(name)
    { ...

Also cout is used the same.

Answer 5

In your Case III, you do pname = (char*) malloc(sizeof(char)); , which allocates enough memory for a single char . However, strcpy has no way of knowing that, and writes over whatever memory comes directly after that byte, until it has finished copying over all of the char* you passed into the function. This is known as a buffer overflow , and while this might immediately work, it could possibly break something down the road. If you are looking to copy only a subsection of the char*, you could look into strncpy , which copies up to some length (API reference here) . If you use that, be sure to add the null-terminating character yourself, as strncpy will not include it if you copy only part of the string.

Answer 6

That pname = (char*) malloc(sizeof(char)); works is coincidental, the call to strcpy writes into memory that hasn't been allocated, so it could crash your program at any time.

A simpler way to initialize your buffer would be:

pname = strdup(name);

or

pname = strndup(name, strlen(name));

See http://linux.die.net/man/3/strdup .

Also, you must think about freeing the memory allocated by calling free(pname); in the class destructor.

All in all, all of this can be avoided by the use of the C++ std::string class, as mentioned by everyone.

Answer 7

Correct is case II!

Yes, case I is wrong, it will crash since you are copying data to a non initialized pointer.

Case III is also wrong, but it works now because your test string is small! If you try with a bigger string it will corrupt memory since you are copying a big string to a small allocated space.

In some systems malloc works with clusters so it works by allocating chuncks of memory instead of allocating byte-by-byte. This means that when you used malloc to alocate a single byte (like you did in case III), it allocates some more up to reach the minimum block of memory it can handle, that's why you could move more then 1 byte to it without crashing the system.