C++

Forum

 
Vector problems

ribenaman (53)
Hi there. I'm currently trying to code up my own Vector container class, starting with a 2D vector, then adding a 3D vector after.

However, after writing up all the functions for the 2D vector, I have a problem initializing it.

Here is the 2D Vector code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
#ifndef VECTOR_H_INCLUDED 
#define VECTOR_H_INCLUDED

template <class T>
struct Vector2D
{
	T x, y;

	Vector2D() : x(0), y(0) {}

	Vector2D(T px, T py) : x(px), y(py) {}

	Vector2D operator +=(const Vector2D& v)
	{
		x += v.x;
		y += v.y;
		return *this;
	}

	Vector2D operator +(const Vector2D& v) const
	{
		Vector2D result = *this;
		result += v;
		return result;
	}

	Vector2D operator -=(const Vector2D v)
	{
		x -= v.x;
		y -= y.x;
		return *this;
	}

	Vector2D operator -(const Vector2D v)
	{
		Vector2D result = *this;
		result -= v;
		return result;
	}

	Vector2D operator *=(float f)
	{
		x *= f;
		y *= f;
		return *this;
	}

	Vector2D operator *(float f) const
	{
		Vector2D result = *this;
		result *= f;
		return result;
	}

	float SquareLen() const
	{
		return x * x + y * y;
	}

	Vector2D Normalise(int x, int y)
	{
		float length = this->SquareLen();
		float oneOverLength = 1.0 / length;
		x *= oneOverLength;
		y *= oneOverLength;
	}

	float DotProduct(const Vector2D v) const
	{
		return x * v.x, y * v.y;
	}

	Vector2D CrossProduct(const Vector2D& u, const Vector2D& v)
	{
		return Vector2D ( x = u.x * v.y - u.y * v.x );
	}
};


#endif


Now, when I try to create a 2DVector in the main.cpp, I get a red line and the error: argument list for class template "Vector2D" is missing

Anyone know what's going on here? Thanks in advance
Aceix (1118)
OP wrote:
error: argument list for class template "Vector2D" is missing


Yeah I think that's because, your class(struct) is a templated one. So if you are creating an object from it, you must explicitly add the template arguments, unlike templated functions.

eg:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
//for templated classes
template<typename T>
class test{
................};

test<int> obj1;

//for templated functions
template<typename T>
void test(T a)
{.................}

int x;
test(x);
//OR
test<int>(x);


That is to say, with the functions, it is optional. But with the class, it is mandatory.

Hope it HELPS!!!
ribenaman (53)
Oh yeah, that was kind of silly of me. Thanks though :)

But now, its telling me that there are no operators for the operators I've written. Is there a special way of calling them because I templated them?
Aceix (1118)
Nah, no special way of calling it--AFAIK
Can you post the error(s)?
And where you are trying to use these operators?
Last edited on
vlad from moscow (6539)
Show the message of the compiler and the relevant code.
ribenaman (53)
1
2
3
4
5
6
7
8
9
10
11
 
// this is all I currently have in the main
#include "Vector.h"
#include <iostream>

int main()
{
	Vector2D<int> testi(1, 4);
	Vector2D<float> testf(3.4, 1.3);

	testi += testf;
}


And this is the .h where I've written the class:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
#ifndef VECTOR_H_INCLUDED 
#define VECTOR_H_INCLUDED

template <class T>
struct Vector2D
{
	T x, y;

	Vector2D() : x(0), y(0) {}

	Vector2D(T px, T py) : x(px), y(py) {}

	Vector2D operator +=(const Vector2D& v)
	{
		x += v.x;
		y += v.y;
		return *this;
	}

	Vector2D operator +(const Vector2D& v) const
	{
		Vector2D result = *this;
		result += v;
		return result;
	}

	Vector2D operator -=(const Vector2D& v)
	{
		x -= v.x;
		y -= y.x;
		return *this;
	}

	Vector2D operator -(const Vector2D& v)
	{
		Vector2D result = *this;
		result -= v;
		return result;
	}

	Vector2D operator *=(float f)
	{
		x *= f;
		y *= f;
		return *this;
	}

	Vector2D operator *(float f) const
	{
		Vector2D result = *this;
		result *= f;
		return result;
	}

	float SquareLen() const
	{
		return x * x + y * y;
	}

	Vector2D Normalise(int x, int y)
	{
		float length = this->SquareLen();
		float oneOverLength = 1.0 / length;
		x *= oneOverLength;
		y *= oneOverLength;
	}

	float DotProduct(const Vector2D& v) const
	{
		return x * v.x, y * v.y;
	}

	Vector2D CrossProduct(const Vector2D& u, const Vector2D& v)
	{
		return Vector2D(x = u.x * v.y - u.y * v.x,
						y = u.y * v.x - u.x * v.y);
	}
};

template <class T>
struct Vector3D
{
	T x, y, z;
	
	Vector3D() : x(0), y(0), z(0) {}
	Vector3D(T px, T py, T pz) : x(px), y(py), z(pz) {}

	Vector3D operator +=(const Vector3D& v)
	{
		x += v.x;
		y += v.y;
		z += v.z;
		return *this;
	}

	Vector3D operator +(const Vector3D& v) const
	{
		result = *this;
		result += v;
		return result;
	}

	Vector3D operator -=(const Vector3D& v)
	{
		x -= v.x;
		y -= v.y;
		z -= v.z;
		return *this;
	}

	Vector3D operator -(const Vector3D& v) const
	{
		result = *this;
		result -= v;
		return result;
	}

	Vector3D operator *=(float f)
	{
		x *= f;
		y *= f;
		z *= f;
		return *this;
	}

	Vector3D operator *(float f)
	{
		result = *this;
		result *= f;
		return result;
	}

	float SquareLen() const
	{
		return x * x, y * y, z * z;
	}

	Vector3D Normalise(int x, int y)
	{
		float length = *this->SquareLen()
		float oneOverLength = 1.0 / length;
		x *= oneOverLength;
		y *= oneOverLength;
		z *= oneOverLength;
	}

	float DotProduct(const Vector3D& v) const
	{
		return x*v.x + y*v.y + z*v.z;
	}

	Vector3D CrossProduct(const Vector3D& u, const Vector3D& v)
	{
		return Vector3D(x = u.y*v.z - u.z*v.y, 
						y = u.x*v.z - u.z*v.x, 
						z = u.y*v.x - u.x*v.y);
	}

	/*typedef Vector2D<int> Vector2Di;
	typedef Vector2D<float> Vector2Df;

	typedef Vector3D<int> Vector3Di;
	typedef Vector3D<float> Vector3Df;*/
//Tried to typedef them here but unfortunately, it made no difference
};


#endif


And, finally, the error:
main.cpp(9): error C2679: binary '+=' : no operator found which takes a right-hand operand of type 'Vector2D<T>' (or there is no acceptable conversion)
with
[
T=float
]
c:\users\..\vector.h(13): could be 'Vector2D<T> Vector2D<T>::operator +=(const Vector2D<T> &)'
with
[
T=int
]
while trying to match the argument list '(Vector2D<T>, Vector2D<T>)'
with
[
T=int
]
and
[
T=float
]

Does this mean that I have to template every use of Vector in the operators?
Peter87 (11234)
Does this mean that I have to template every use of Vector in the operators?

If you want the operators to work with any type of Vector you have to do that, yes.

1
2
3
4
5
6
7
 
template <typename T2>
Vector2D operator +=(const Vector2D<T2>& v)
{
	x += v.x;
	y += v.y;
	return *this;
}

vlad from moscow (6539)
Vector2D<int> and Vector2D<float> are two different types. You defined the operator += for objects that have the same type that is either the both objects have type Vector2D<int> or the both objects have type Vector2D<float>.

To use the operator += with different types you should write a template operator of the class as @Peter87 has shown.
Topic archived. No new replies allowed.