i was wondering if anyone can explain whats going on

[4NCRDjzh]

Uuj job just

[LB]

You forgot to ask a question.

[EpicViTTo23]

It looks to me like this code is an implementation of an Array. In the main You are setting the array size to three(values) at first. It looks like the Arr class defaults values to zero when it creates them so the next line in main is setting the values for the memory you just created in the array. After the first three elements are set the array size is "grown" to 5, again the new values are defaulted to zero. Next you create another array "arr2" and you tell it to have 1234 bytes in memory waiting to be used(not values). Then you set arr2 equal to the first array that was created using the assignment operator. Finally, "arr3" gets created to show an example of the copy constructor being used and is set to equal "arr2", then "arr3" gets printed to screen. Does this help at all? I agree a specific question would be helpful.

[Enoizat]

I’d like to know your opinions of the subtlety at line 29:
ar.set(0, 10), ar.set(1, 11), ar.set(2, ar.get(1));

Why does the author use the comma operator, which isn’t overloaded?
Does s/he need to introduce a sequence point
https://en.wikipedia.org/wiki/Sequence_point
or some other ‘nasty’ :-) C++ trick I don’t know?

I mean, could that line have been split into:

ar.set(0, 10);
ar.set(1, 11);
ar.set(2, ar.get(1));

with exactly the same effect or not?

Sorry to take advantage of your post to remedy my ignorance, @Boyprodigy, but my question also helps answering yours.

[EpicViTTo23]

It's funny, i only briefly skimmed the code before i posted and didn't really catch the use of comma's there. It is sort of a strange thing to do because your right, using semicolons works and is way more standard. However, i think the author was just trying to emphasize the fact that they were setting the values of an array like structure.

[Enoizat]

May I keep this thread alive just for another day?
I’m sorry to bother you all with a code you clearly are not interested in, but as far as I can see, there’s nothing ‘special’ in this code, apart for this line:
ar.set(0, 10), ar.set(1, 11), ar.set(2, ar.get(1));

I was wondering whether the comma operator was used to introduce a “sequence point” and EpicViTTo23, very reasonably, hypothesized it could be a way to emphasize the values were to be input into an array-like structure.

I’d be grateful to anyone who might venture further explanation.

I’m copying it inside the code tags to make it easier to be analysed:

// CS 540, Test Prog 4, Bob Hart

#include <iostream>
#include <new>
#include <string>
#include <cstdlib>
using namespace std;

class Arr {
public:
    Arr(unsigned els);
    Arr(const Arr & other); // you didn't have to write a copy ctor
    ~Arr();
    unsigned getSize() const;
    void set(unsigned index, int value);
    int get(unsigned index) const;
    friend ostream & operator<<(ostream & out, const Arr & ar);
    void grow(unsigned newEls);
    Arr & operator=(const Arr & rhs);
private:
    // helper func allocates array & initializes to 0's
    static int * alloc(unsigned els);
    int * _data;
    unsigned _els;
}; // class Fraction


bool die(const string & msg);


int main()
{
    Arr ar(3);
    ar.set(0, 10), ar.set(1, 11), ar.set(2, ar.get(1)); // {10, 11, 11}
    ar.grow(5); // {10, 11, 11, 0, 0}
    Arr arr2(1234);
    arr2 = ar;
    Arr arr3(arr2);
    cout <<"{ 10 11 11 0 0} == " <<arr3 <<endl;
}


Arr::Arr(unsigned els): _data(alloc(els)), _els(els) 
{}


Arr::Arr(const Arr & other): _data(alloc(other._els)), _els(other._els)
{
    for(unsigned i = 0; i < _els; i++)
    _data[i] = other._data[i];
}


Arr::~Arr() 
{ delete[] _data; cout <<"d"; }


unsigned Arr::getSize() const 
{ return _els; }


void Arr::set(unsigned index, int value) 
{ _data[index] = value; }


int Arr::get(unsigned index) const 
{ return _data[index]; }


ostream & operator<<(ostream & out, const Arr & ar)
{
    out <<"{";
    for(unsigned i = 0; i < ar._els; i++)
        out <<" " <<ar._data[i];
    return out <<"}";
}


void Arr::grow(unsigned newEls)
{
    int * newData = alloc(newEls);
    for(unsigned i = 0; i < _els; i++)
        newData[i] = _data[i];
    delete[] _data; cout <<"d";
    _data = newData;
    _els = newEls;
}


Arr & Arr::operator=(const Arr & rhs)
{
    if(this != &rhs) {
        delete[] _data; cout <<"d";
        _data = alloc(_els = rhs._els);
        for(unsigned i = 0; i < _els; i++)
        _data[i] = rhs._data[i];
    }
    return *this;
}


int * Arr::alloc(unsigned els)
{
    int * ret = nullptr;
    try {
        ret = new int[els]();
    } catch(const bad_alloc &) {
        die("Arr: allocation failure");
    }
    cout <<"n";
    return ret;
}


bool die(const string & msg)
{
    cout <<"Fatal error: " <<msg <<endl;
    exit(EXIT_FAILURE);
}