Expectedy copy constructor not elided

[artaxerxe]

I have the following class:

class IntArray
{
private:
    int m_size;
    int *m_array;

public:
    IntArray(int s)
    {
        m_array = new int[s];
    }
    IntArray(const IntArray &arr): m_array(nullptr)
    {
        std::cout << "Called copy constructor.";
        m_size = arr.m_size;
        m_array = new int[arr.m_size];
        for (int i { 0 }; i < arr.m_size; ++i)
        {
            m_array[i] = arr.m_array[i];
        }
    }

    ~IntArray()
    {
        delete[] m_array;
    }

    int &operator[](int index) const
    {
        assert(index >= 0 && index < m_size && "Index is out of range.");
        return m_array[index];
    }

    friend std::ostream &operator<<(std::ostream &out, const IntArray &arr);
    friend int runEx9_x_3();

};

Operator overloading isn't relevant I think.
This code executes:

int runEx9_x_3()
{
    IntArray a{ 5 };
    a[0] = 5;
    a[1] = 8;
    a[2] = 2;
    a[3] = 3;
    a[4] = 6;
    std::cout << a << '\n';

    IntArray &ref{ a };
    IntArray b(1);
    b = a;
    std::cout << "(&b == &a) = " << (&b == &a) << '\n';
    std::cout << "(b.m_array == a.m_array) = " << (b.m_array == a.m_array) << '\n';
    std::cout << "(&(b.m_size) == &(a.m_size)) = " << (&(b.m_size) == &(a.m_size)) << '\n';
    a.m_array[2] = 111; // last change. Modify b.m_array too. Why?

    std::cout << b << '\n';
    std::cout << a << '\n';

    return 0;
}

The output is:

[5 8 2 3 6 ]
(&b == &a) = 0
(b.m_array == a.m_array) = 1
(&(b.m_size) == &(a.m_size)) = 0
[5 8 111 3 6 ]
[5 8 111 3 6 ]

I expect that the last change which I did on underlying array of "a" object affect only this. But I see that in fact "b"'s array is the same. So I conclude that my copy constructor is elided. Why? As far as I'm concerned, it shouldn't. Can anybody explain me why this behavior?

Thanks.

[Repeater]

Your copy constructor is not elided. It's just not being used, because you're never copy constructing anywhere in your code.

 IntArray b(1);  // This is not a call to a copy constructor
  b = a; // Neither is this - this is an assignment operator 

This is the assignment operator:

  IntArray& operator=(IntArray other)
    { 
          std::cout << "Called assignment operator.";
          // Write code here
        
    }

Because you didn't write one yourself, you get a default one. Add that assignment operator to your code and you'll see it get called.

This is a copy constructor use:
IntArray b(a);

[artaxerxe]

Got it know. And fixed it. Thanks.