templatized class inside templatized class

what is wrong with the implementation of the add function for the vector class here?

Code:

---

namespace project {
template <class _T>
class type
{
 public :
        type();
        type(int num);

        type( const type & typ);
        ~type();

 protected :
        _T val;

};

template <class type, size_t n>
class vector
{
  public:

  // constructors/destructor
    vector( );                        // default constructor (size==0)
 
    vector( const vector & vec );    // copy constructor
    ~vector( );                      // destructor

  // operator overloads
    const vector & operator = ( const vector<type, n>& vec );

  // add element to a vector
    void add(type value);
 
    vector<type, n>& operator+=(const vector<type, n>& vec);
    vector<type, n>& operator-=(const vector<type, n>& vec);

  // unary
    vector<type, n>& operator-();       
       
  // member functions
    int  length( ) const;                  // capacity of vector

  //read access operator for a polynomial
    const type& operator[]( int index ) const;
       
  //write access operator for a polynomial
    type& operator[]( int index );

 protected:   
    int csize;
    int  size;                            // # elements in array
    type * list;                          // array used for storage
   
};

template <class type, size_t n>
void vector<type, n>::add(type value)
{
 this.list[this.csize] = value;
 this.csize++;
}
}

---

you have to put the method implementation inside the class declaration.

Code:

---

template <class _T>
class type
{
 public :
        type();
        type(int num);

        type( const type & typ);
        ~type();

 protected :
        _T val;

};

template <class type, size_t n>
class vector
{
  public:

  // constructors/destructor
    vector( );                        // default constructor (size==0)
 
    vector( const vector & vec );    // copy constructor
    ~vector( );                      // destructor

  // operator overloads
    const vector & operator = ( const vector<type, n>& vec );

  // add element to a vector
    void vector::add(type value)
    {
    this.list[this.csize] = value;
    this.csize++;
    }

 
    vector<type, n>& operator+=(const vector<type, n>& vec);
    vector<type, n>& operator-=(const vector<type, n>& vec);

  // unary
    vector<type, n>& operator-();       
       
  // member functions
    int  length( ) const;                  // capacity of vector

  //read access operator for a polynomial
    const type& operator[]( int index ) const;
       
  //write access operator for a polynomial
    type& operator[]( int index );

 protected:   
    int csize;
    int  size;                            // # elements in array
    type * list;                          // array used for storage
   
};

---

also, what is the purpose of n and the class "type"? you are probably going down the wrong road with those.

n is the vector size which is implemented as an array

the requirements is:

•Your template class should be called vector. Note that the template parameters for your vector
class will necessarily be different from those of the std::vector class.
• Your vectors should have elements of type, with fixed length n.
• Elements of type must support the full set of operators provided below‡. Elements must be able
to take as their optional constructor argument an int.

I don't really think that the implementation must be inside the class

I got the following error when trying to use the add:
vector_main.cpp:13: error: no matching function for call to âece373::vector<int,u>::add(ece373::type<int>&)â
vector.h:171: note: candidates are: void ece373::vector<type, n>::add(type) [with type = int, unsigned int n = 3u]

Quote:

---

Originally Posted by -EquinoX-

what is wrong with the implementation of the add function for the vector class here?

---

You forgot that this is a pointer.

so how can I fix this?

You can either remove the this. or change them to this->.

Code:

---

I don't really think that the implementation must be inside the class

---

d'oh of course. that is correct. you just can't put it in a separate file.

Quote:

---

Originally Posted by laserlight

You can either remove the this. or change them to this->.

---

I even removed that and it still gives me the error... I think the problem is in the function signature

Quote:

---

Originally Posted by -EquinoX-

I even removed that and it still gives me the error... I think the problem is in the function signature

---

Then post the smallest and simplest program that demonstrates the error.

here's my test:

Code:

---

using namespace project;

int main(){
 type<int> e(1);
 vector<int, 3> a;
 a.add(e);
}

---

Notice that vector is a vector<int, 3>, not a vector<type<int>, 3>.

ok now I got a different error:

vector_main.cpp:(.text+0xb0): undefined reference to `project::type<int>::type(project::type<int> const&)'
CMakeFiles/vector.dir/vector_main.cpp.o: In function `project::vector<project::type<int>, 3u>::vector()':
vector_main.cpp:(.text._ZN6project6vectorINS_4type IiEELj3EEC1Ev[project::vector<project::type<int>, 3u>::vector()]+0x5a): undefined reference to `project::type<int>::type()'


FYI: I encapsulate the whole .h file above into a namespace called project, see my edited code above

reading your assignment, it is my interpretation that your professor did not intend for you to implement a separate class called type.

You declared but did not define the copy constructor for project::type. You did not define the default constructor for project::type, but it is used by project::vector's default constructor.

I've attached my code for you to see, I have the constructor and everything. I have the constructor and everything, and yes I've confirmed that I need to create a class called type as I need to create a templatized class of vector that stores a type

Quote:

---

Originally Posted by m37h0d

reading your assignment, it is my interpretation that your professor did not intend for you to implement a separate class called type.

---

then how would you satisfy this if you don't have a class

Elements must be able to take as their optional constructor argument an int.

Quote:

---

Originally Posted by -EquinoX-

I have the constructor and everything

---

No, you did not implement the default constructor and copy constructor for project::type. Frankly, you do not even need to declare the copy constructor, copy assignment operator and destructor for project::type.

Furthermore, note that names that begin with an underscore followed by an uppercase letter (or that contain consecutive underscores) are reserved to the implementation (i.e., compiler and standard library) for any use. As such, _VECTOR_H is not a good choice for a header inclusion guard, and you should use T instead of _T for the template parameter. Additionally, use T instead of type for the project::vector template parameter; type is too confusing, especially when you have a class template named type.

Quote:

---

Originally Posted by -EquinoX-

yes I've confirmed that I need to create a class called type as I need to create a templatized class of vector that stores a type

---

As in you have checked with your instructor? After all, int is a type, so you do not need type<int> unless there is some special reason.

Quote:

---

Originally Posted by -EquinoX-

Elements must be able to take as their optional constructor argument an int.

---

That can be interpreted as a constraint on the types that project::vector can be instantiated with.

Quote:

---

Originally Posted by laserlight

That can be interpreted as a constraint on the types that project::vector can be instantiated with.

---

how can this be done? mind giving an example...

all he's said to me is:

vector is made of up of type objects, so that constraint belongs only to the template parameter used for your class. I am guessing you're right, but not quite clear by constraint belong to the template parameter

Quote:

---

Originally Posted by -EquinoX-

how can this be done? mind giving an example...

---

Consider this function template:

Code:

---

template<typename T>
void swap(T& x, T& y)
{
    T t(x);
    x = y;
    y = t;
}

---

Objects of type T must be copyable. This does not mean that you have to create a class template so that you have objects that are copyable, rather, it means that you can only use this swap function template with objects of built-in or pointer types, or of a class type with a public copy constructor and public copy assignment operator.

so what would I need to change in my original class besides of erasing the type class?

also it takes an int... what is the int for

Quote:

---

Originally Posted by -EquinoX-

so what would I need to change in my original class besides of erasing the type class?

---

Well, if I were you, I would store a std::vector<T> instead of a T*, and thus get rid of the copy constructor and destructor and the compiler supplied ones would then suffice. Actually, in that case csize and size would also become unnecessary.

I am lost to what you're saying there.... store a std::vector<T> inside my templatized vector class..

Quote:

---

Originally Posted by -EquinoX-

I am lost to what you're saying there.... store a std::vector<T> inside my templatized vector class..

---

Before I give an example... what exactly does this mean?

Quote:

---

Your vectors should have elements of type, with fixed length n.

---

So, the vectors should have a fixed length of n?

yes that is true... it should have a fixed size and that is done by using the template as I have specified in my code post

I think I understand what you mean now, you're asking me to store my vector using the std::vector, that makes sense... however, still, how do I enforce this one

Elements must be able to take as their optional constructor argument an int.

Is this basically saying that if my vector stores an int then the int can have an argument int? makes no sense at all to me.... 1(2) ???

Quote:

---

Originally Posted by -EquinoX-

I think I understand what you mean now, you're asking me to store my vector using the std::vector, that makes sense...

---

Actually, since the maximum length is fixed, you could use a std::tr1::array instead, or:

Code:

---

#include <cstddef>
#include <stdexcept>

template<typename T, std::size_t N>
class vector
{
public:
    vector() : size(0) {}

    void add(const T& value);
    vector& operator+=(const vector& other);
    vector& operator-=(const vector& other);
    vector operator-() const;
    T& operator[](std::size_t index);
    const T& operator[](std::size_t index) const;
    std::size_t length() const;
private:
    T elements[N];
    std::size_t size;
};

template<typename T, std::size_t N>
void vector<T, N>::add(const T& value)
{
    if (size == N)
    {
        throw std::length_error("Maximum size of vector exceeded!");
    }

    elements[size++] = value;
}

---

Quote:

---

Originally Posted by -EquinoX-

Elements must be able to take as their optional constructor argument an int.

Is this basically saying that if my vector stores an int then the int can have an argument int? makes no sense at all to me.... 1(2) ???

---

What it means is that you should be able to use integer values to initialise the elements. This would be the case for the built-in types, and also certain class types, e.g., std::complex<double>.

What it means is that you should be able to use integer values to initialise the elements

Please can you give me an example of this... I don't quite get it...

Quote:

---

Originally Posted by -EquinoX-

What it means is that you should be able to use integer values to initialise the elements

Please can you give me an example of this... I don't quite get it...

---

I am partially guessing because you did not give the full requirements. Basically, I believe that your instructions are to create a vector type that has elements of types that behave like the integer types. I cannot show you a good example because I am not sure what this vector class is really supposed to do. If you want a direct example:

Code:

---

int x = 0;

---

That is what I mean by using an integer value to initialise x. Or more generically:

Code:

---

T x = 0;

---

or if we use direct initialisation:

Code:

---

T x(0);

---

What's T? It could be an int, a long, a double, a std::complex<double> (for the direct initialisation example), my own Integer type, etc.

I guess you're right, but how is this used in the vector class? so say I have a vector called a and I want to add an int with a value 2.2... how would I do it?

Quote:

---

Originally Posted by -EquinoX-

I guess you're right, but how is this used in the vector class? so say I have a vector called a and I want to add an int with a value 2.2... how would I do it?

---

You already did it in your initial version, and my example in post #26 is just a variant of yours. What are the += and -= operators supposed to do?

you mentioned above about constraints, where in the code that you suggested is the constraint that would enforce it to take an int as an argument?

the += is just an operator overloading to add two vectors

Quote:

---

Originally Posted by -EquinoX-

you mentioned above about constraints, where in the code that you suggested is the constraint that would enforce it to take an int as an argument?

---

The partial example that I gave does not make use of that. What it does make use of is a copy assignment operator, which I assume is among "the full set of operators provided below". If it is not... then your best option is to use a std::vector instead of an array of N elements (and if you are not allowed to use std::vector, then you should use placement new, and everything just becomes more complicated).

Quote:

---

Originally Posted by -EquinoX-

the += is just an operator overloading to add two vectors

---

Sure, but what does "add two vectors" mean? You have to be clear on that, since it could mean the pairwise addition of the elements of the two vectors, or it could mean the concatenation of one vector to the other, or something else.

I guess it would add each element that is the vector with each element on the other vector, if the size doesn't match it would throw an exception..

here's the continuation of the instruction, if you wish to know the full set of operators provided below are:

Your template class should provide at least the following class or global operator methods:
1 =, ==, !=, +, +=, -, -=, [ ]. Both binary, and unary, operator- should be provided.
2 In operations with scalar type values, the operators *, /, *=, /= can be used.

which raises up a new question, how can the element type also have the following operators...

Don't you want something like

Code:

---

vector& operator*=(const vector& other)
{
    if (this->size != other.size)
        throw std::length_error("No matching size");
    for(int i=0; i < this->size; ++i)
        this->elements[i] *= other.elements[i];
    return *this;
}

---

or

Code:

---

vector& operator*=(const vector& other)
{
    for(int i=0; i < this->size && i < other.size; ++i)
        this->elements[i] *= other.elements[i];
    return *this;
}

---

but it only says for operation with scalar values... so how can I know if it's scalar or not, is it directly saying that if I am storing a vector of char or string then I can't use this

anyone care to give me some insights?

Code:

---

template<typename T,size_t N>foo
{
  private:
    T  arr[N];
  public:
    foo& operator*=(T t)
    {
      for(size_t i=0;i<N;++i)
      {
          arr[i]*=t;
      }
      return *this;
    }
};

---

what if what's stored in i can't be multiplied by t? what if T is a char or a string?

also after giving it some thought, I think type is a class, as the vector is storing an object of type... therefore type is another class... I just don't know how can I make so that type can implement the same operator that vector has, such as *=, etc and I don't know the purpose of type having an int as an argument... if type is a string, then the string takes an int as an argument... but what is that int for in a string? any ideas?

Quote:

---

Originally Posted by -EquinoX-

so how can I know if it's scalar or not, is it directly saying that if I am storing a vector of char or string then I can't use this

---

A char is a scalar.

Quote:

---

Originally Posted by -EquinoX-

what if what's stored in i can't be multiplied by t? what if T is a char or a string?

---

Then that is the user's problem (though in the case of char or any integer/floating point type, overflow is also a problem, but at run time). In some later version of C++ there may be the concept of concepts, where it can be clearly enforced that a template can only be instantiated with a type that supports certain operations, but for now (and perhaps even in C++0x) such a feature does not exist, though Boost.ConceptCheck makes an attempt at it.

Quote:

---

Originally Posted by -EquinoX-

also after giving it some thought, I think type is a class, as the vector is storing an object of type... therefore type is another class... I just don't know how can I make so that type can implement the same operator that vector has, such as *=, etc and I don't know the purpose of type having an int as an argument... if type is a string, then the string takes an int as an argument... but what is that int for in a string? any ideas?

---

It is the other way round: you tell your users: my template works with types that support these operations with these semantics. If you instantiate it with a type that does not support these operations or with the wrong semantics, good luck.

look at std::valarray.

I think the only way I can restraint it is for the template class vector to take an object type... type can be anything but then I can guarantee that type has all the overload operators

no you can't. you're just kicking the can down the road.

the point of making that restriction is that your vector class isn't supposed to be used with any type!

if you make a Type<std::string> you're going to get a compilation error in Type just the same as you with vector<std::string> if you ever use *= operator of the class.

you're still looking at the phrasing of the assignment backwards:

Quote:

---

2 In operations with scalar type values, the operators *, /, *=, /= can be used.

---

you're looking at this as a requirement of your class to provide a way to support those operators no matter what stupid thing gets specified as a template parameter type.

what that really means is that is the operators that can be used with your vector - it's a requirement of the parameter types, not your vector! you must provide them and use the parameter type's operator, but you are not supposed to try to support an operator that doesn't exist.

besides, you'll see that eventually, if you ever intend to use those operators, the underlying paramter type must have them implemented anyway, so your strategy just adds a layer of complication with no gain over the simpler implementation i am suggesting to you.

Code:

---

#include <valarray>



int _tmain(int argc, _TCHAR* argv[])
{
  std::valarray<std::string>thisMakesNoSense;
  thisMakesNoSense*="asdf";
        return 0;
}

---

well it's a requirement for both the vector and the type parameter... I am only confused on how can I make so that whatever type is the parameters then it would support those operators

Quote:

---

Originally Posted by -EquinoX-

I think the only way I can restraint it is for the template class vector to take an object type... type can be anything but then I can guarantee that type has all the overload operators

---

If you really want to make sure that vector's element type can support all the operators, then the solution is to create a vector class and an element class. Note, classes, not class templates. Once you involve templates, it becomes possible to try to instantiate the template with a type that does not support the operations required.

Quote:

---

Originally Posted by -EquinoX-

well it's a requirement for both the vector and the type parameter... I am only confused on how can I make so that whatever type is the parameters then it would support those operators

---

Assume that the type supports those operators and thus make use of them. The compiler will then enforce this requirement for you by spitting out an error if the user attempts to call a function that assumes that a particular operator is available when it is not.

Quote:

---

Originally Posted by -EquinoX-

well it's a requirement for both the vector and the type parameter... I am only confused on how can I make so that whatever type is the parameters then it would support those operators

---

this compiles

Code:

---

#include <valarray>

int _tmain(int argc, _TCHAR* argv[])
{
  std::valarray<std::string>thisMakesAtLeastSomeSense;
  thisMakesNoSense+="asdf";
        return 0;
}

---

because string has a += operator

this doesn't.

Code:

---

#include <valarray>

int _tmain(int argc, _TCHAR* argv[])
{
  std::valarray<std::string>thisMakesNoSense;
  thisMakesNoSense*="asdf";
        return 0;
}

---

because string doesn't have a *= operator.

what you still don't realize is that even if you create a template class that has the operator in question, you can't guarantee you can use it.

you're transferring the inevitable compilation error from your vector class to your element class.

Quote:

---

Originally Posted by laserlight

If you really want to make sure that vector's element type can support all the operators, then the solution is to create a vector class and an element class. Note, classes, not class templates. Once you involve templates, it becomes possible to try to instantiate the template with a type that does not support the operations required.

---

if he doesn't use templates, then he can't actually use the operators at all can he?

Quote:

---

Originally Posted by m37h0d

Code:

---

I don't really think that the implementation must be inside the class

---

d'oh of course. that is correct. you just can't put it in a separate file.

---

Sure you can, although it wouldn't be normal. The definition just has to be available somehow, that's all.

okay, I am now 100% sure after consulting here and there that I don't need to create an element class.. all I need is just one template vector class.. only two problem left..

1. how can I make sure that the element (which will be stored inside the vector) supports all of
this operators:

=, ==, !=, +, +=, -, -=

2. any idea why the element takes an int? I've been thinking all day and can't seem the reason

Quote:

---

Originally Posted by -EquinoX-

okay, I am now 100% sure after consulting here and there that I don't need to create an element class.. all I need is just one template vector class.. only two problem left..

1. how can I make sure that the element (which will be stored inside the vector) supports all of
this operators:

=, ==, !=, +, +=, -, -=

2. any idea why the element takes an int? I've been thinking all day and can't seem the reason

---

i already showed you #1.

re: #2, only thing that occurred to me was looping over the array of T's and initializing each one with its index in the array.

for #1, you only showed me that some types makes sense to use *= and some don't, but it doesn't really tell me that the element supports all of the operator, correct me if I am understanding you wrong

the compiler will tell you as soon as someone tries to use an operator that doesn't exist.

Quote:

---

Originally Posted by m37h0d

if he doesn't use templates, then he can't actually use the operators at all can he?

---

Of course he can, since he explicitly provides them, i.e., creating one's own number class.

Quote:

---

Originally Posted by m37h0d

re: #2, only thing that occurred to me was looping over the array of T's and initializing each one with its index in the array.

---

Yes, though strictly speaking that is assignment, not initialisation.

does all type takes an int as an argument in the constructor?

Quote:

---

Originally Posted by -EquinoX-

does all type takes an int as an argument in the constructor?

---

All objects of built-in types can be initialised with an int or have an int assigned to them, but they do not actually have constructors. For class types, it depends on the class type. As I noted, some class types are deliberately designed as numeric types and thus have similiar behaviour in many respects, e.g., the std::complex class template.

Quote:

---

Originally Posted by laserlight

Of course he can, since he explicitly provides them, i.e., creating one's own number class.

---

aah ok, i see what you mean. no abstraction or genericity at all.

Quote:

---

Yes, though strictly speaking that is assignment, not initialisation.

---

you're correct, i phrased myself poorly. i was thinking of the initialization on the right hand side...i.e.:

Code:

---

arr[i]=T(i);

---

Quote:

---

does all type takes an int as an argument in the constructor?

---

not every class does, but if in your constructor, you assign each element in your array to an instance that has been constructed with one, then any type put into your vector must.

e.g:

Code:

---

template<typename T,size_t N>foo
{
  private:
    T  arr[N];
  public:
    foo()
    {
      for(size_t i=0;i<N;++i)
      {
          arr[i]=T(i);
      }
    }
};

---

so I came to a conclusion that there is no way to make sure that type has all the operators:

=, ==, !=, +, +=, -, -=

and every objects of built in type can take an int as a constructor

that's what i've been trying to tell you! :)

okay, now define what is an objects of built in type?

oh that's an easy one; you should know that! the native types:

int, char, unsigned int, float, double, long, etc.

Quote:

---

Originally Posted by -EquinoX-

so I came to a conclusion that there is no way to make sure that type has all the operators:

=, ==, !=, +, +=, -, -=

---

Requiring the type to have all of those operators is probably too strict a requirement, since !=, +, and - can be represented in terms of the other ones.

If you see a != b, you can replace with !(a == b)

If you see a + b, you can replace with a temporary which is copy-constructed or assigned from a, then invoke += b on it.

Similar for a - b.

I would only require =, ==, +=, -=

One way to avoid the problem of operators not implemented by the class is to simply use a template function. That way, as long as the user doesn't try to invoke the operator, no error occurs. For example:

Code:

---

template < typename T >
struct test
{
    template < typename U >
    test& operator *= ( U const& rhs )
    {
        value *= rhs;
        return *this;
    }

    T value;
};

int main( void )
{
    test< string > ts; // fine
    ts *= string( ); // error
}

---

Quote:

---

Originally Posted by brewbuck

Requiring the type to have all of those operators is probably too strict a requirement, since !=, +, and - can be represented in terms of the other ones.

If you see a != b, you can replace with !(a == b)

If you see a + b, you can replace with a temporary which is copy-constructed or assigned from a, then invoke += b on it.

Similar for a - b.

I would only require =, ==, +=, -=

---

Yep, excellent suggestion.

okay, I have another question now regarding operators between two vectors of different size:
What does this sentence mean:

If you check for mismatched sizes, but it is impossible for the sizes to be mismatched based on strong typing (i.e., the compiler will fail)

Can you give me an example of when this could happen and how to prevent this in my vector template class.

I'm not sure what that actually means, honestly. Can you provide the complete requirements (or at least a link to it)?

The full requirements:

When operations between vectors of unequal size are performed, exceptions should be thrown, or the compile should fail. If you check for mismatched sizes, but it is impossible for the sizes to
be mismatched based on strong typing (i.e., the compiler will fail),

No, I mean the full requirements for the entire assignment. That might aid in infering the meaning from the context of everything else. From what I can tell, checking for mismatched sizes doesn't even require an operation on the element type, so there should never be a complication error in the first place. I was hoping that maybe the rest of requirements might shed some light on the statement in question.

I can't copy the whole assignment here.

Quote:

---

Originally Posted by Sebastiani

One way to avoid the problem of operators not implemented by the class is to simply use a template function. That way, as long as the user doesn't try to invoke the operator, no error occurs.

---

That is already the case with the member functions of the class template.

it's important to remember that classes instantiated from the same template, but with different template parameters are totally separate types. they are not related to each other. a foo<int,2> is a different type than a foo<int,3>.

thus any template class method that accepts expects its own type as a function parameter cannot accept a class instantiated from the same template with different parameters.

do you follow?

the reason to have the type take an int is so that I can do the following:

Code:

---

vector<class, 2> temp;
vector<class, 2> temp 2;

temp2[0] = 1;
temp2[1] = 2;

vector<int, 2> result = temp + temp2;

---

it is said to initialize temp to 0, but how can this be possible with a type taking an int?