classe template utilisation

Bonjour,

Comment utilise-t-on, dans le main, cette classe template ?

Code:

1
2
3
4
5
6
7
8
9
10
11
 
template <class R, class RR>
class P2 {
 
public:
R x, y;
P2 (R a, R b): x(a), x(b)  {}
P2<R,RR> operator+(const P2<R,RR> & cc) const
{return P2<R,RR>(x+cc.x,y+cc.y) ;}
 
};

Bonjour

Une fois la typo corrigée dans le constructeur :

Code:

1
2
3
4
5
6
7
P2<int, int> a(0, 1);
P2<int, int> b(1, 0);
P2<int, int> c = a + b;
 
std::cout << "a = " << a.x << " " << a.y << std::endl;
std::cout << "b = " << b.x << " " << b.y << std::endl;
std::cout << "c = " << c.x << " " << c.y << std::endl;

Par contre ce code est à bannir. Il faut rendre ce code plus propre. Tu peux t'inspirer ce cette classe vector2.

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
/// Container for 2 values
template <class T>
class vector2
{
public:
 
	/// x
	T x;
 
	/// y
	T y;
 
	/**
         * @brief Constructor
         * @param[in] x x
         * @param[in] y y
         */
	explicit vector2<T>(T const & x=T(), T const & y=T()) : x(x), y(y) { }
 
	/**
         * @brief Equality operator
         * @param[in] v A vector2
         * @return true if vector2 have same values, false otherwise
         */
	bool operator==(vector2 const & v) const { return (x == v.x && y == v.y); }
 
	/**
         * @brief Inequality operator
         * @param[in] v A vector2
         * @return true if vector2 have different values, false otherwise
         */
	bool operator!=(vector2 const & v) const { return (! ((*this) == v)); }
 
};
 
/**
 * @brief Display a vector2
 *
 * @param[in,out] o Out stream
 * @param[in]     c A vector2
 *
 * @return the out stream
 */
template <class T>
std::ostream & operator << (std::ostream & o, vector2<T> const & v)
{
	o << "{" << v.x << ", " << v.y << "}";
	return o;
}

les deux sont aussi terribles. template alias + std::array please

Pourquoi pas :)
Le .x et .y sont sympas. Et on veut pas forcément redéfinir les opérateurs pour std::array<T, 2> (?)