std::array copy semantics

Question

#include <array>
#include <iostream>

using namespace std;

struct SimpleDebugger
{
    SimpleDebugger(int val = 0) : x(val) {
        cout << "created" << endl;
    }

    SimpleDebugger(const SimpleDebugger &that) : x(that.x) {
        cout << "copied" << endl;
    }

    ~SimpleDebugger() {
        cout << "killed!" << endl;
    }

    int getX() const {
        return x;
    }

    void setX(int val) {
        x = val;
    }

private:
    int x;
};

array<SimpleDebugger, 3> getInts(int i)
{
    array<SimpleDebugger, 3> a;
    a[0].setX(i);
    a[1].setX(i + 1);
    a[2].setX(i + 2);
    cout << "closing getInts" << endl;
    return a;
}

SimpleDebugger (*getIntsArray(int i)) [3] {
    typedef SimpleDebugger SimpleDebugger3ElemArray [3];
    SimpleDebugger3ElemArray *sd = new SimpleDebugger3ElemArray[1];
    (*sd)[0].setX(i);
    (*sd)[1].setX(i + 1);
    (*sd)[2].setX(i + 2);
    cout << "closing getIntsArray" << endl;
    return sd;
}

ostream& operator << (ostream& os, const SimpleDebugger &sd) {
    return (cout << sd.getX());
}

int main() {
    auto x = getInts(5);
    cout << "std::array = " << x[0] << x[1] << x[2] << endl;
    auto y = getIntsArray(8);
    cout << "Raw array = " << (*y)[0] << (*y)[1] << (*y)[2] << endl;
    delete [] y;
}

Output

created
created
created
closing getInts
std::array = 567
created
created
created
closing getIntsArray
Raw array = 8910
killed!
killed!
killed!
killed!
killed!
killed!

I tried this above program to see how convenient it is to use std::array over raw arrays, I know that avoiding old-style arrays is good style and even better is to use std::vector.

I'd like to know what happens under the hood in case of std::array, when the function getInts() returns. In case of the raw arrays, I know that it's a pointer copy and the onus of cleaning it up falls on the callee. In std::array this doesn't happen, but how does it internally store the data and how does the copy happen?

If you are using g++, try the test again with -fno-elide-constructors for another possible output. — Robᵩ
– Robᵩ, Commented Jan 24, 2013 at 19:35

Mike Seymour · Accepted Answer · 2013-01-24 19:36:27Z

8

std::array is an aggregate, containing an array as its only data member. Copying or moving one will copy or move each element of the array into the new array.

In your case the copy is being elided when it's returned from the function; under the hood, the array is created in automatic storage in main, and the function fills in that array.

answered Jan 24, 2013 at 19:36

Mike Seymour

256k30 gold badges467 silver badges658 bronze badges

Sign up to request clarification or add additional context in comments.

14 Comments

legends2k Over a year ago

+1 Doesn't this property of std::array make it less performant that old-style arrays?

Mike Seymour Over a year ago

@legends2k: It's exactly as perfomant as a built-in array for everything a built-in array can do. It's also copyable and movable.

legends2k Over a year ago

I think I get it, one would never return a built-in array, or simply one can't rather, and just becasue std::array can be returned, returning it would make it less preformant as would be the case with any container type. Am I right in inferring this?

Mike Seymour Over a year ago

@legends2k: Indeed, move semantics and copy/move elision (or RVO if you prefer) are two different phenomena. Values returned from a function will be moved if possible, so there's no need to use std::move; and the compiler should elide the copy/move whenever it can.

legends2k Over a year ago

Clarified now, and thanks for replying to all my comments patiently :)

|

Collectives™ on Stack Overflow

std::array copy semantics

1 Answer 1

14 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

14 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related