Storing Class object in an array

Please take a look at the following:

dispenserType type[4];
dispenserType appleJuice();
type[0] = appleJuice;
dispenserType orangeJuice();
type[1] = orangeJuice;
dispenserType mangoLassi();
type[2] = mangoLassi;
dispenserType fruitPunch();
type[3] = fruitPunch;

as you can see i have stored different objects in the type array.

The dispenserType class has a constructor that sets the number of items to 20. so we have int numberfItems for the object appleJuice set to 20 so on and so forth.

The same class has also the following methods: method that decreases the numberOfItems by one:

void dispenserType::makeSale()
int dispenserType::getNoOfItems() const
    return numberOfItems;

If for example the following is called:

cout << appleJuice.getNoOfItems() << endl;

then the program would display the right numberOfItmes, which is 19. On the other hand, if cout<<type[0].getNoOfItems() is called, then it would display the number 20.

That behavior leads me to think that appleJuice and type[0] are two separate objects.

My questions is, is there a way to create an array of objects without needing to declare an object and store in an array as I did it as I did?

thank you.


You are correct, type[0] and appleJuice are two different objects.

Option #1 - You can use an array of objects without cloning each object:

dispenserType type[4];

Option #2 - You can use an array of pointers instead of an array of objects:

dispenserType* type[4];
for (int i=0; i<sizeof(type)/sizeof(*type); i++)
    type[i] = new dispenserType();

And of course, you will have to delete each allocated object at some later point during execution:

for (int i=0; i<sizeof(type)/sizeof(*type); i++)
    delete type[i];

You are not storing any objects, because you aren't creating any. This is a function declaration:

dispenserType appleJuice();

You need

dispenserType appleJuice;


dispenserType appleJuice{}; // C++11

Once you fix that, then yes, doing this

type[0] = appleJuice;

assigns the value of appleJuice to an already existing object type[0]. It is the same as saying

dispenserType a;
dispenserType b;

b = a;  // b and a are different objects

My questions is, is there a way to create an array of objects without needing to declare an object and store in an array as I did it as I did?

For a plain array, the only way is to use an initialization list, because once it is initialized, all you can do is modify its existing elements. So

dispenserType type[3] = { dispenserType(args), 
                          dispenserType(other args), 
                          dispenserType(other args) };

An alternative is to construct an std::vector<dispenserType> and emplace_back elements into it.

Need Your Help

Associativity in Lambda calculus

lambda-calculus associativity

I am working on the exercise questions of book The Lambda calculus. One of the questions that I am stuck is proving the following:

Are there factors except the encoding which manipulate the result of urlencode?

php encoding utf-8 character-encoding

The situation: I'm developing a PHP Script which connects to a mssql database via odbc interface. After matching data gathered, these are transmitted through a REST interface to an external server....