how can implement a template class like this

actually, i wanna implement a matrix class. and i also want to enable the member function to initialize the buffer where the data stores.
i ve considered two means, one is overload function, another is initialization list.
but it seems not possible for doing that as i hoped
could anyone provides me a little advice
thanks alot

Code:

template<typename T>
class Mat{
 public:
// ....
    Mat();
    ~Mat();

private:
T ** mem;
}


int main(void)
{
   Mat a = { {1,2,3}, {2,3,4}};
// or Mat a({1,2,3},{2,3,4});
 return 0;
}[

Read this:
std::initializer_list - Cppreference

Get the sizes of the buffers to allocate by caling the size() function of the relevant lists.
And a for loop, with the iterators to copy.

Originally Posted by manasij7479

Read this:
std::initializer_list - Cppreference

Get the sizes of the buffers to allocate by caling the size() function of the relevant lists.
And a for loop, with the iterators to copy.

thanks mana,
that is to say specifing values directly to the buffer is impossible, am i right

Originally Posted by letmoon

thanks mana,
that is to say specifing values directly to the buffer is impossible, am i right

Not impossible, pass (loaded) pointers directly,
..or if you're upto some adventure, learn about move constructors(and use a container to store the data, instead of a T**).

It doesn't have anything to do with templates. It doesn't have anything to do with classes.

You can't ever do that in C++98. That sort of member initialization requires that the members be known.

The `mem' member variable is known as just being a pointer to a pointer to `T'. You can initialize it as being a point to a pointer to `T'. It isn't known to be an array or anything of the sort so you can't initialize it like one.

The following code works because you are initializing an array.

Code:

struct Test
{
    unsigned int m[2][2];
};

int main()
{
    Test l = {{{0, 1}, {2, 3}}};
    return(0);
}

For C++98 your best bet is to avoid the approach. I'd follow the standard set by others and use a range based constructor.

That said, at cost, you can emulate the behavior through secondary template classes by using the size as a parameter and initializing that object.

Soma

thanks Soma,
actually, in addtion to this one. i also wanna implement some operator overloads

Originally Posted by manasij7479

Not impossible, pass (loaded) pointers directly,
..or if you're upto some adventure, learn about move constructors(and use a container to store the data, instead of a T**).

vector, for example

Code:

typedef vector<int> i_vec;

// in the class
// private:
 vector<i_vec> buffer;

Originally Posted by letmoon

vector, for example

How about ,

Code:

std::vector<std::vector<T> >

instead of T** ?
You don't have to manually maintain any size info, and your assignment will easily work.

Code:

Mat(const std::vector<std::vector<T> >& v):mem(v)
{
}

//Disclaimer for phantomotap : C++11 feature used.
The nested initializer list will be converted to your nested vector implicitly.

Oh.. and in main, you missed the template parameter : Mat<int>

Originally Posted by phantomotap

It doesn't have anything to do with templates. It doesn't have anything to do with classes.

You can't ever do that in C++98. That sort of member initialization requires that the members be known.

The `mem' member variable is known as just being a pointer to a pointer to `T'. You can initialize it as being a point to a pointer to `T'. It isn't known to be an array or anything of the sort so you can't initialize it like one.

The following code works because you are initializing an array.

Code:

struct Test
{
    unsigned int m[2][2];
};

int main()
{
    Test l = {{{0, 1}, {2, 3}}};
    return(0);
}

For C++98 your best bet is to avoid the approach. I'd follow the standard set by others and use a range based constructor.

That said, at cost, you can emulate the behavior through secondary template classes by using the size as a parameter and initializing that object.

Soma

Originally Posted by manasij7479

How about ,

Code:

std::vector<std::vector<T> >

instead of T** ?
You don't have to manually maintain any size info, and your assignment will easily work.

Code:

Mat(const std::vector<std::vector<T> >& v):mem(v)
{
}

//Disclaimer for phantomotap : C++11 feature used.
The nested initializer list will be converted to your nested vector implicitly.

Oh.. and in main, you missed the template parameter : Mat<int>

thanks u both, really helpful

theres multiple problems here. for one, a 2d array is not the same thing as a pointer-to-pointer. also, you cannot implicitly size static arrays of more than one dimension.


the closest you could come to what you're after is using implicit conversion, like so:

Code:

template<typename T>
class Mat{
 public:
    template<unsigned int Rows,unsigned int Columns>Mat(const T(&data)[Rows][Columns]):
		rows(Rows),
		columns(Columns),
		mem(new T[Rows*Columns])
	{
		memcpy(mem,data,sizeof(T)*Rows*Columns);
	}
    ~Mat()
	{
		delete[] mem;	
	}
	const unsigned int rows;
	const unsigned int columns;
	T& operator()(unsigned int row,unsigned int column)
	{
		return mem[row*columns+column];
	}
	const T& operator()(unsigned int row,unsigned int column)const
	{
		return mem[row*columns+column];
	}
private:
T *mem;
};
 


int _tmain(int argc, _TCHAR* argv[])
{
	int data[][3] =  {{1,2,3}, {2,3,4}};
    Mat<int> a = data;
	for(unsigned int row = 0; row < a.rows; ++row)
	{
		for(unsigned int column=0; column < a.columns; ++column)
		{
			std::cout << a(row,column) << '\t';
		}
		std::cout << '\n';
	}
	std::cin.get();
}

i wouldn't recommend doing it this way personally, but here it is.

the closest you could come to what you're after is using implicit conversion

O_o

Except for the things already discussed (for C++11 and C++98 hacks for a `std::initializer_list' style object).

Soma

i got pulled away and didn't refresh the page before i posted. not familiar with those.

*shrug*

It doesn't matter. Having another option isn't a bad thing.

Soma

Originally Posted by m37h0d

theres multiple problems here. for one, a 2d array is not the same thing as a pointer-to-pointer. also, you cannot implicitly size static arrays of more than one dimension.


the closest you could come to what you're after is using implicit conversion, like so:

i wouldn't recommend doing it this way personally, but here it is.

I would recommend you at least use std::copy instead of memcpy. Otherwise you will get problems with non-primitive types.
(In fact, don't use memcpy in C++.)

Yes, it is a matrix, but it does not need to contain ints or floats or doubles.
It can contains YourCustomIntegerClass. This is C++, you know... you are using a template class. You cannot be sure of the type T.
If you use std::copy, it will be correct in all cases. If you use memcpy, you will get silent errors in some cases. Why chase ghosts when a simple line can fix it?