Correct implementation of copy constructor for allocated pointers

Question

I have a class, which contains some allocated pointers (reduced to 1 in the example), and I would like not to have to deep copy when the copy operator is called. The class is the following:

class Example {
    public:
    Example() : ptr1(0), len1(0) {} 
    Example(const Example& other) : ptr1(0), len1(0) {
        if (other.ptr1) {
            ptr1 = other.ptr1;
            len1 = other.len1;
        }
    }
    ~Example() {
        if (ptr1)
            delete[] ptr1;
    }
    char* ptr1;
    int len1;
};

A reasonable use after free happens when I try to create some Example class, assign the pointers, and insert it into a cointainer that has scope outside the function in which assingment and insertion happens :

// some function
{
    Example a;
    a.ptr1 = new char[1];
    vec.push_back(Example); // some std::vector<Example> I created outside the function call.
}

I know by deep copying that this could be solved. Or by inserting an empty Example and then operate with the Example copy that the map saved, but I would like to know if there are more options. The sandard I'm using is C++11.

Answer 1

Having seen your comment, here is one alternative not included in The Dreams' answer. The simplest way out, as suggested by Sebastian's comment, is to just treat Example as not owning its data at all:

struct Example {
    char* ptr1 = nullptr;
    int len1 = 0;
};

Since this has a default destructor and copy/move functions provided by the compiler, it will not release any allocated memory. However, managing that outside the scope of the class might be the easier solution.

If you do wish to tie the fate of the allocated memory to the class, you could still make use of smart pointers with something along the lines of point 3 in the other answer. The top answer to your cited question shows how you can specify a custom deleter function to a shared pointer. For completeness, an example with std::unique_ptr:

#include <cstdlib>
#include <memory>

class Example {
    std::shared_ptr<char[]> ptr1;
    int len1;

    public:
    template<typename Deleter>
    Example(std::unique_ptr<char[], Deleter>&& p = nullptr, int len = 0)
        : ptr1{std::move(p)}, len1{len} {}
};

struct MyDeleter {
    void operator()(char* p) { free(p); }
};

int main() {
    auto* chars = static_cast<char*>(malloc(sizeof(char)));
    Example a {std::unique_ptr<char[], MyDeleter>(chars), 1};
}

Answer 2

I know by deep copying that this could be solved. Or by inserting an empty Example and then operate with the Example copy that the map saved, but I would like to know if there are more options

For custom classes only you define what it means for them to be copied.

1. Copy the owned resources If you consider the class instance should unchallengly own the resource, you better move the allocation part (i.e. any use of new keyword) under the hood of the class implementation, essentially making a handle of the resource out of your class (this way you also follow so-called RAII idiom). Standard library, however, already has handles implemented for such a popular thing as arrays. Depending on your requirements you can choose out of rich collection of container classes, but in case of char arrays you actually better just use std::string:

#include <string>
#include <vector>

class Example {
    std::string resource;
    
public:
    Example(const std::string& str) : resource{ str } {}
    
    Example(const Example& other) : resource{ other.resource } {}

};

int main(int argc, char * argv[]) {
    std::vector<Example> collection;
    collection.emplace_back("test");
    return EXIT_SUCCESS;
}

2. Move the owned resource provided your class owns the resource, but you don't want to copy it, in C++ you have a luxury of moving semantic. It comes handy when you don't actually need to work with the source instance of the copy, and can save some calculation power by moving the resource instead of making any copy of it. You can even make std containers use your move constructor (instead of copy) when they re-allocate internal space. All you need to do to introduce it for your custom class is to provide a noexcept move constructor:

class Example {
    std::string resource;
    
public:
    Example(const std::string& str) : resource{ str } {}
    
    Example(const Example& other) : resource{ other.resource } {}
    Example(Example&& other) noexcept : resource{ std::move(other.resource) } {}
};

3. Share the resource If you consider the class instances to "share" resources, i.e. multiple instances can have access to the same resource, then widely advertised std::shared_ptr comes very handy. It takes responsibility for tracking how many pointers exist to the resource and deallocate the resource for you when all such pointers were destroyed:

#include <memory>
#include <vector>

class Example {
    std::shared_ptr<char[]> resource;
    std::size_t length;    
    
public:
    Example(std::unique_ptr<char[]> _resource, std::size_t _length) : resource{ std::move(_resource) }, length{ _length } {}
    
    Example(const Example& other) : resource{ other.resource }, length{ other.length } {}

};

int main(int argc, char * argv[]) {
    std::vector<Example> collection;
    collection.emplace_back(std::make_unique<char[]>(8), 8);
    return EXIT_SUCCESS;
}