GCC:Static(fixed-length) array in template class

Hi.

I'm using GCC's c++ compiler, and when attempting to create a template class containing an N-length array;

Code:

template <int N>
class C
{
public:
    { ... }
private:
    { ... }
    int _array[N];
};

... and start using(i.e. calling functions manipulationg C::_array) a single instance of the class; everything is fine. But when several instances exist, the array is zeroed-out, and stays that way.

If I use a dynamic array, then no problem. Is there any way to get fixed-length arrays as class-members in GCC-c++?

Thanks in advance!

Originally Posted by tra86

... and start using(i.e. calling functions manipulationg C::_array) a single instance of the class; everything is fine. But when several instances exist, the array is zeroed-out, and stays that way.

It is very likely that the problem exists somewhere else. You might, for example, be writing to global C instances, while reading the local ones. You have to provide more code or a complete compilable example.

Since the C++ standard does not support VLA (Variable Length Arrays) I would recommend that you use std::vector, dynamic memory, or possibly std::array if you are compiling with C++0x. Although g++ may support VLA as a compiler extension I would not recommend using this extension because until gcc version 4.5 VLA are listed as broken.

Jim

That's not a VLA.

Originally Posted by jimblumberg

Since the C++ standard does not support VLA (Variable Length Arrays) I would recommend that you use std::vector, dynamic memory, or possibly std::array if you are compiling with C++0x. Although g++ may support VLA as a compiler extension I would not recommend using this extension because until gcc version 4.5 VLA are listed as broken.

Jim

This is perfectly fine since N is known at compile time (this is how std::array is implemented).

There is not enough to actually identify the problem, so I would suggest you try to make a smallest compilable example that demonstrates the problem.

Btw, a name that begins with an underscore and a small letter is reserved for implementation use. You should not use that.

There is nothing wrong with the snippet posted.

As kmdv said, the problem is elsewhere.

Soma

Hi. I found the problem and as you said, the problem was elsewhere; marked in the following code.

Code:

template <typename T, std::size_t NDimensions>
class Vector
{
public:
	typedef T value_type;
	typedef std::size_t size_type;
	
	enum { dimensions = NDimensions };
	
	Vector(std::initializer_list<value_type> list) 
	{
		init();
		
		size_type ix = 0;
		for (typename std::initializer_list<value_type>::iterator it = list.begin();
			it != list.end(); ++it, ++ix)
		{
			_values[ix] = *it;
		}
	}
	
	Vector(const Vector &rhs)
	{
		init();
		
		for (size_type i = 0; i < dimensions; ++i)
		{
			_values[i] = rhs._values[i];
		}
	}
	
	Vector()
	{
		init();
		
                // Problem was Here:
		memset(_values, 0, sizeof(_values) * sizeof(*_values));
                // Changed it to
                // -- memset(_values, 0, dimensions * sizeof(value_type));
	}
	
	~Vector()
	{
		//delete _values;
	}
	
	Vector &operator=(const Vector &rhs)
	{
		for (size_type i = 0; i < dimensions; ++i)
		{
			_values[i] = rhs._values[i];
		}
		
		return *this;
	}
	
	value_type &operator[](size_type index)
	{
		return _values[index];
	}
	
	const value_type &operator[](size_type index) const
	{
		return _values[index];
	}
	
private:
	void init()
	{
		//_values = new value_type[dimensions];
	}

	//value_type *_values;
        value_type _values[dimensions];
};

Now it works as a static array, i can see it from the object size. Thanks for all the replies!

I still don't get why memset(_values, 0, sizeof(_values) * sizeof(*_values)); works for a dynamic but not for a fixed-length array thou, but thats not so important.

In your initializer list constructor, make sure the length of the initializer list is not greater than the size of your array!
Also, memset is not recommended in C++. Actually, it's outright dangerous. Use std::fill instead.

And actually,
memset(_values, 0, sizeof(_values) * sizeof(*_values));
would not work for a dynamic length array since sizeof(_values) would be the size of the pointer, and not the array.
Also, sizeof returns the entire size (in bytes) of the array, so don't multiply it with anything.

Btw, a name that begins with an underscore and a small letter is reserved for implementation use. You should not use that.

I thought it was just names beginning with a double underscore or an underscore and an uppercase letter that were reserved?

Originally Posted by tra86

I still don't get why memset(_values, 0, sizeof(_values) * sizeof(*_values)); works for a dynamic but not for a fixed-length array thou, but thats not so important.

Like Elysia said, this would cause a buffer overflow. You're filling too much memory, a factor of sizeof(*_values) more memory than you should be touching, with that code.

Originally Posted by dwks

I thought it was just names beginning with a double underscore or an underscore and an uppercase letter that were reserved?

My memory served me wrong. You are correct.
To make it a (little) easier, one might remember to avoid all names starting with an underscore.