Skip to content

Memcpy Vs Assignment Pointers Run

Generally speaking, the worst case scenario will be in an un-optimized debug build where is not inlined and may perform additional sanity/assert checks amounting to a small number of additional instructions vs a for loop.

However is generally well implemented to leverage things like intrinsics etc, but this will vary with target architecture and compiler. It is unlikely that will ever be worse than a for-loop implementation.

People often trip over the fact that memcpy sizes in bytes, and they write things like these:

You can protect yourself here by using language features that let you do some degree of reflection, that is: do things in terms of the data itself rather than what you know about the data, because in a generic function you generally don't know anything about the data:

Note that you don't want the "&" infront of "myGlobalArray" because arrays automatically decay to pointers; you were actually copying "nums" to the address in memory where the pointer to the myGlobalArray[0] was being held.

Using on objects can be dangerous, consider:

This is the WRONG way to copy objects that aren't POD (plain old data). Both f1 and f2 now have a std::string that thinks it owns "hello". One of them is going to crash when they destruct, and they both think they own the same vector of integers that contains 42.

The best practice for C++ programmers is to use :

This can make compile time decisions about what to do, including using or and potentially using SSE/vector instructions if possible. Another advantage is that if you write this:

and later on change Foo to include a , your code will break. If you instead write:

the compiler will switch your code to do the right thing without any additional work for you, and your code is a little more readable.

9.15 — Shallow vs. deep copying

Shallow copying

Because C++ does not know much about your class, the default copy constructor and default assignment operators it provides use a copying method known as a memberwise copy (also known as a shallow copy). This means that C++ copies each member of the class individually (using the assignment operator for overloaded operator=, and direct initialization for the copy constructor). When classes are simple (e.g. do not contain any dynamically allocated memory), this works very well.

For example, let’s take a look at our Fraction class:

The default copy constructor and assignment operator provided by the compiler for this class look something like this:

Note that because these default versions work just fine for copying this class, there’s really no reason to write our own version of these functions in this case.

However, when designing classes that handle dynamically allocated memory, memberwise (shallow) copying can get us in a lot of trouble! This is because shallow copies of a pointer just copy the address of the pointer -- it does not allocate any memory or copy the contents being pointed to!

Let’s take a look at an example of this:

The above is a simple string class that allocates memory to hold a string that we pass in. Note that we have not defined a copy constructor or overloaded assignment operator. Consequently, C++ will provide a default copy constructor and default assignment operator that do a shallow copy. The copy constructor will look something like this:

Note that m_data is just a shallow pointer copy of source.m_data, meaning they now both point to the same thing.

Now, consider the following snippet of code:

While this code looks harmless enough, it contains an insidious problem that will cause the program to crash! Can you spot it? Don’t worry if you can’t, it’s rather subtle.

Let’s break down this example line by line:

This line is harmless enough. This calls the MyString constructor, which allocates some memory, sets hello.m_data to point to it, and then copies the string “Hello, world!” into it.

This line seems harmless enough as well, but it’s actually the source of our problem! When this line is evaluated, C++ will use the default copy constructor (because we haven’t provided our own). This copy constructor will do a shallow copy, initializing copy.m_data to the same address of hello.m_data. As a result, copy.m_data and hello.m_data are now both pointing to the same piece of memory!

When copy goes out of scope, the MyString destructor is called on copy. The destructor deletes the dynamically allocated memory that both copy.m_data and hello.m_data are pointing to! Consequently, by deleting copy, we’ve also (inadvertently) affected hello. Variable copy then gets destroyed, but hello.m_data is left pointing to the deleted (invalid) memory!

Now you can see why this program has undefined behavior. We deleted the string that hello was pointing to, and now we are trying to print the value of memory that is no longer allocated.

The root of this problem is the shallow copy done by the copy constructor -- doing a shallow copy on pointer values in a copy constructor or overloaded assignment operator is almost always asking for trouble.

Deep copying

One answer to this problem is to do a deep copy on any non-null pointers being copied. A deep copy allocates memory for the copy and then copies the actual value, so that the copy lives in distinct memory from the source. This way, the copy and source are distinct and will not affect each other in any way. Doing deep copies requires that we write our own copy constructors and overloaded assignment operators.

Let’s go ahead and show how this is done for our MyString class:

As you can see, this is quite a bit more involved than a simple shallow copy! First, we have to check to make sure source even has a string (line 8). If it does, then we allocate enough memory to hold a copy of that string (line 11). Finally, we have to manually copy the string (lines 14 and 15).

Now let’s do the overloaded assignment operator. The overloaded assignment operator is slightly trickier:

Note that our assignment operator is very similar to our copy constructor, but there are three major differences:

  • We added a self-assignment check.
  • We return *this so we can chain the assignment operator.
  • We need to explicitly deallocate any value that the string is already holding (so we don’t have a memory leak when m_data is reallocated later).

When the overloaded assignment operator is called, the item being assigned to may already contain a previous value, which we need to make sure we clean up before we assign memory for new values. For non-dynamically allocated variables (which are a fixed size), we don’t have to bother because the new value just overwrite the old one. However, for dynamically allocated variables, we need to explicitly deallocate any old memory before we allocate any new memory. If we don’t, the code will not crash, but we will have a memory leak that will eat away our free memory every time we do an assignment!

A better solution

Classes in the standard library that deal with dynamic memory, such as std::string and std::vector, handle all of their memory management, and have overloaded copy constructors and assignment operators that do proper deep copying. So instead of doing your own memory management, you can just initialize or assign them like normal fundamental variables! That makes these classes simpler to use, less error-prone, and you don’t have to spend time writing your own overloaded functions!

Summary

  • The default copy constructor and default assignment operators do shallow copies, which is fine for classes that contain no dynamically allocated variables.
  • Classes with dynamically allocated variables need to have a copy constructor and assignment operator that do a deep copy.
  • Favor using classes in the standard library over doing your own memory management.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

#include <cassert>

#include <iostream>

classFraction

{

private:

    intm_numerator;

    intm_denominator;

public:

    // Default constructor

    Fraction(intnumerator=0,intdenominator=1):

        m_numerator(numerator),m_denominator(denominator)

    {

        assert(denominator!=0);

    }

    friendstd::ostream&operator<<(std::ostream&out,constFraction&f1);

};

std::ostream&operator<<(std::ostream&out,constFraction&f1)

{

out<<f1.m_numerator<<"/"<<f1.m_denominator;

returnout;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

#include <cassert>

#include <iostream>

classFraction

{

private:

    intm_numerator;

    intm_denominator;

public:

    // Default constructor

    Fraction(intnumerator=0,intdenominator=1):

        m_numerator(numerator),m_denominator(denominator)

    {

        assert(denominator!=0);

    }

    // Copy constructor

    Fraction(constFraction&f):

        m_numerator(f.m_numerator),m_denominator(f.m_denominator)

    {

    }

 

    Fraction&operator=(constFraction&fraction);

 

    friendstd::ostream&operator<<(std::ostream&out,constFraction&f1);

};

std::ostream&operator<<(std::ostream&out,constFraction&f1)

{

out<<f1.m_numerator<<"/"<<f1.m_denominator;

returnout;

}

 

// A better implementation of operator=

Fraction&Fraction::operator=(constFraction&fraction)

{

    // self-assignment guard

    if(this==&fraction)

        return*this;

    // do the copy

    m_numerator=fraction.m_numerator;

    m_denominator=fraction.m_denominator;

    // return the existing object so we can chain this operator

    return*this;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

#include <cstring> // for strlen()

#include <cassert> // for assert()

 

classMyString

{

private:

    char*m_data;

    intm_length;

public:

    MyString(constchar*source="")

    {

        assert(source);// make sure source isn't a null string

 

        // Find the length of the string

        // Plus one character for a terminator

        m_length=strlen(source)+1;

        

        // Allocate a buffer equal to this length

        m_data=newchar[m_length];

        

        // Copy the parameter string into our internal buffer

        for(inti=0;i<m_length;++i)

            m_data[i]=source[i];

    

        // Make sure the string is terminated

        m_data[m_length-1]='\0';

    }

    ~MyString()// destructor

    {

        // We need to deallocate our string

        delete[]m_data;

    }

    char*getString(){returnm_data;}

    intgetLength(){returnm_length;}

};

MyString::MyString(constMyString&source):

    m_length(source.m_length),m_data(source.m_data)

{

}

intmain()

{

    MyString hello("Hello, world!");

    {

        MyString copy=hello;// use default copy constructor

    }// copy is a local variable, so it gets destroyed here.  The destructor deletes copy's string, which leaves hello with a dangling pointer

 

    std::cout<<hello.getString()<<'\n';// this will have undefined behavior

 

    return0;

}

1

    MyString hello("Hello, world!");

1

    MyString copy=hello;// use default copy constructor

1

}// copy gets destroyed here

1

    std::cout<<hello.getString()<<'\n';// this will have undefined behavior

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

// Copy constructor

MyString::MyString(constMyString&source)

{

    // because m_length is not a pointer, we can shallow copy it

    m_length=source.m_length;

 

    // m_data is a pointer, so we need to deep copy it if it is non-null

    if(source.m_data)

    {

        // allocate memory for our copy

        m_data=newchar[m_length];

 

        // do the copy

        for(inti=0;i<m_length;++i)

            m_data[i]=source.m_data[i];

    }

    else

        m_data=0;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

// Assignment operator

MyString&MyString::operator=(constMyString&source)

{

    // check for self-assignment

    if(this==&source)

        return*this;

 

    // first we need to deallocate any value that this string is holding!

    delete[]m_data;

 

    // because m_length is not a pointer, we can shallow copy it

    m_length=source.m_length;

 

    // m_data is a pointer, so we need to deep copy it if it is non-null

    if(source.m_data)

    {

        // allocate memory for our copy

        m_data=newchar[m_length];

 

        // do the copy

        for(inti=0;i<m_length;++i)

            m_data[i]=source.m_data[i];

    }

    else

        m_data=0;

 

    return*this;

}