Thread: Initializing member arrays in constructors?

I am curious how to go about intializing a member variable if it is an array, and the size isn't given until it compilation. Doing so would better encapsulate the code which is the point of thise whole practice.

Here's a simple code example...

Code:

#ifndef STACK_H
#define STACK_H

#include <iostream>

#define SIZE		100

class Stack
{
private:
	int m_stck[SIZE];
	int m_tos;
public:
	Stack();
	void Push(int i);
	int Pop();
};

#endif

What I am interested in is having Stack's constructor take in a "size" arguement and pass it into m_stck. This way, there's one less define constant in the program. And of course, I can set each Stack object to different max sizes which would be a nice benefit. Some may just need 20, some may need 100. But just figuring out how to do this in general would be great to know down the road. Something like this is what I'm looking for...

Code:

Stack::Stack(int size) {
   // pass size into m_size[]'s brackets. 
}

Please note I'm using Stack as an example. I can see many classes that might require a similar task. Mainly what I'm trying to understand is how to pass a variable into a member array within an object. If I didn't, SIZE would always be the same value!

the size isn't given until it compilation

You mean, SIZE would be a compile-time constant? Another option might be a static const in the class. (Just having a const member is not enough, because these can be initialized at run-time with a variable, but static array sizes need to be known at compile-time.)

It should also be possible to use a template parameter for size - like std::bitset - to generate code for Stack objects of varying size, but all the different sizes need to be known while compiling.

If you mean you want SIZE to be determined at run-time, you'll need to go with dynamic allocation (or may-be use std::vector as the underlying container for the stack as it manages the memory for you).

Note that some compilers may allow declarations of static arrays with variable run-time size (because C allows it) but that is not standard and portable.

I'm the smartest man alive

In main(), I did this...

Code:

	Stack s(10);  // give it a size of 10

	s.Push(1);
	s.Push(2);
	s.Push(3);

	std::cout << s.Pop() << std::endl;
	std::cout << s.Pop() << std::endl;
	std::cout << s.Pop() << std::endl;

Stack's header:

Code:

#ifndef STACK_H
#define STACK_H

#include <iostream> 

class Stack
{
private:
	int *m_stck;
	int m_tos;
	int m_size;
public:
	Stack(int size);
	~Stack();
	void Push(int i);
	int Pop();
};

#endif

And Stack.cpp:

Code:

#include "stack.h"

// Stack constructor
Stack::Stack(int size)
{
	m_tos = 0; 
	m_stck = new int[size];
	m_size = size;
}

Stack::~Stack() 
{
	if (m_stck) {
		delete m_stck; 
		m_stck = NULL;
	}
}

// Pushes a value onto the stack.
void Stack::Push(const int i) 
{
	if (m_tos == m_size) {
		std::cout << "Stack is full." << std::endl;
		return;
	}

	m_stck[m_tos] = i;
	m_tos++;
}

// Pops a value from the stack.
int Stack::Pop()
{
	if (m_tos == 0) {
		std::cout << "Stack underflow." << std::endl;
		return -1;
	}

	m_tos--;
	return m_stck[m_tos];
}

I noticed:

Code:

Stack::~Stack() 
{
	if (m_stck) {
		delete m_stck; 
		m_stck = NULL;
	}
}

Deleting a null pointer is safe, so you can delete m_stck even if it is null. However, m_stck was allocated with new[], so you must use delete[] on it, not delete.

Okay, thanks. I'm a bit confused confused with when to use delete [] and just delete. Got any examples on when to choose? Is [] just for arrays? Thanks a ton.

Oh, I think I know...
int *p = new int; // call delete p afterwards.
int *p = new int[size]; // call delete [] p

Pair new with delete and pair new[] with delete[]. new[] would be used for dynamic arrays.

Just a note: you are actually assigning values in your constructor, not initialising the member variables. You should use an initialisation list instead.

I'm not sure if I know what you mean.

m_stck = new int[size]; // this gives it the max size to store
m_stck[1]; // this hasn't been given a value yet since m_tos is at 0 initialially. Push(int i) would do the assigning.

Are you suggesting to clear the dynamic array out with a value (like -1)?

I think something like this second constructor might be good though...
Stack(int size, int initValue);

initValue would do something like this...

Code:

for (int i = 0; i < m_size; i++) { 
  m_stck[i] = initValue; 
}

Push() should receive an unsigned value too. Ah well, it's all extra candy now that I could add. I'm just glad to know I got the dynamic array within a class down.

I had in mind:

Code:

// Stack constructor
Stack::Stack(int size) : m_tos(0), m_stck(new int[size]), m_size(size)
{
}

Especially since size is an int instead of an unsigned int, you might want to delay the new[] until the constructor body or you can validate m_size (and provide a default size instead, if it is non-positive).

That's a good idea. I'm wondering if the other way is more readable though. But for a few variables being assigned that way isn't too big of a deal to add.

I'm curious when to use that option though. Is it just when there's a few variables to store? Would you use the block if you need to check for validity? For example, it might be a good idea to throw an exception if there's not enough memory for the array allocation.

I'm afraid that if you want to inline these functions you'll need to provide the implementation in the header file (in the class declaration, where they would be implicitly inlined). The inlined function implementation needs to be in the same compilation unit where it is used (compilation unit = e.g main.cpp + headers that main.cpp includes + headers these headers might include).

Vectors are good if you don't know how much might be in the stack. If you know it's going to be around 20 items, chances are performance is slightly better.

Well, not necessarily. Vector could be beaten if it needs to reallocate, but you can avoid that by using reserve. And if your estimate is wrong (you're prepared for 24, but you actually need 25), you're in trouble, because it would be hard to write a reallocation mechanism as good as that of a vector (unless may-be you are writing it for a specific simple type and not a templated Stack).

It just seems like half of the arguements would be in the init list and the rest in the body... maybe harder to find later? It's just new to me.

I'm not sure what you mean here. Do you think it is confusing to have things initialized in two places? Now only half of them will be hard to find. But if they all were in the body, all would be harder to find.

I guess a programmer must live with it, that in code it is hard to find things...

Or do you mean that you're running a risk of not initializing m_password in some cases? But then it is your problem as a programmer to solve. Throw an exception if there's no sensible default value for m_password and you can't put the object in a good state. Or else, if a default value is meaningful, you might use it to initialize the member to it in the initialization list.

Nitpick:

Code:

   Customer(unsigned int password) { 
         if ((password >= 0) && (password < 5000))
               m_password = password;
          }