How to deep copy an array of char * in C++

It’s for a programming assignment, and the teacher wants all strings to be stored as char*,...

You can tell your teacher that std::string does store strings as char*. If he still doesnt like you to use std::string you should write your own wrapper, because working with bare char* is what you do when you write C, but not in C++. You should write a:

struct my_string {
    char* data;
    ... constructor, operator[], etc...
};

You basically dont need to write more code than you already do, but you should put it in the right place (ie hide it behind a nice interface). You will immediately see the benefit of it when you eg consider ...

...so an array of strings has to be stored as an array of char*.

No. An array of strings is std::array<my_string> (or std::vector<my_string> if it is supposed to be dynamic). And if your teacher insists on not using std::vector, then you should do the same as you just did for strings for vectors (ie encapsulate all the dirty pointer and memory stuff in one place).

This seems more like a C question, but here is an example:

char **AllocateAndDeepCopy(char **arr1, int arr1size) 
{
    unsigned int    i;
    char            **arr2;

    /* Allocate string array */
    arr2 = new char*[arr1size];

    /* Iterate array elements */
    for (i=0; i<arr1size; i++) {
        /* Allocate string */
        arr2[i] = new char[strlen(arr1[i])+1];

        /* Copy contents */
        strcpy(arr2[i], arr1[i]);
    }   

    return arr2;
}

Later you have to deallocate arr2 this way:

void DeallocateArr2(char **arr2, int size) 
{
    for (int i=0; i<size; i++) {
        delete arr2[i];     
    }

    delete arr2;
}

I can only shake my head about the sorry state of C++ education. We have a looong way to go there. But since that’s apparently a given, what’s the best you can do?

To copy a C-style data structure like that you have know two things at the point of copy. Both are not inherently provided by a C-style array, so you’ll have to track them explicitely.

• The capacity of arr1: 20. If that’s not a compile time constant you have to store it and pass it around. Since you want to implement a copy ctor that means storing the capacity in a non-static member variable of the object.
• The number of used indexes in arr1: 2. Same as above. Alternatively make sure that all unused indexes are set to nullptr.

Now you can allocate an arr2 of the correct size and then allocate+memcpy all used indexes.

However, your program will go up in flames regardless, because arr1 and arr2 cannot be treated the same, even though they look identical. The used indexes of arr1 must never ever be deleted because they contain pointers to character literals: They were never newd and live in read-only memory. On the other hand you absolutely must delete the indexes of arr2, because they were newd.

If this brutal disregard of const is really required by the assignment I’d go one step further. I’d introduce another member variable, an array of booleans that tracks which indexes of the char array point to char literals and which were dynamically allocated. During copy you now have all the necessary information to either memcpy or simply set the pointer. Crazy? Definitely, but the whole assignment is, and that way the craziness is visible at least instead of hidden behind an innocent-looking C-style cast. Btw: those should be const_cast<char*> to make it clear what’s going on.

Just take a look at http://en.cppreference.com/w/cpp/algorithm/copy, the deep copy is made by *d_first++ = *first++;