[已解决]C++ 模板类特化中的变量问题

hellomyprogram

我有这一段代码：

1. #include <array>
   
2. template <unsigned short dimensions>
   
3. class Vector
   
4. {
   
5.         public:
   
6.                 static const unsigned short dimension = dimensions;
   
7.                 std::array<double, dimensions> values;
   
8.                 Vector() = default;
   
9.                 Vector(const Vector &) = default;
   
10.                 Vector(Vector &&) = default;
    
11.                 Vector(std::array<double, dimensions> values)
    
12.                 {
    
13.                         this->values = values;
    
14.                 };
    
15.                 Vector<dimensions> & operator=(const Vector<dimensions> &) = default;
    
16.                 Vector<dimensions> operator+(const Vector<dimensions> &other) const
    
17.                 {
    
18.                         Vector<dimensions> result;
    
19.                         for (unsigned short index = 0; index < dimensions; index++)
    
20.                         {
    
21.                                 result.values[index] = this->values[index] + other.values[index];
    
22.                         };
    
23.                         return result;
    
24.                 };
    
25.                 Vector<dimensions> operator+(const double other) const
    
26.                 {
    
27.                         Vector<dimensions> result;
    
28.                         for (unsigned short index = 0; index < dimensions; index++)
    
29.                         {
    
30.                                 result.values[index] = this->values[index] + other;
    
31.                         };
    
32.                         return result;
    
33.                 };
    
34.                 Vector<dimensions> operator-() const
    
35.                 {
    
36.                         Vector<dimensions> result;
    
37.                         for (unsigned short index = 0; index < dimensions; index++)
    
38.                         {
    
39.                                 result.values[index] = -this->values[index];
    
40.                         };
    
41.                         return result;
    
42.                 };
    
43.                 Vector<dimensions> operator-(const Vector<dimensions> &other) const
    
44.                 {
    
45.                         return (*this) + -other;
    
46.                 };
    
47.                 Vector<dimensions> operator-(const double other) const
    
48.                 {
    
49.                         return *this + -other;
    
50.                 };
    
51.                 Vector<dimensions> operator*(const double other) const
    
52.                 {
    
53.                         Vector<dimensions> result;
    
54.                         for (unsigned short index = 0; index < dimensions; index++)
    
55.                         {
    
56.                                 result.values[index] = this->values[index] * other;
    
57.                         };
    
58.                         return result;
    
59.                 };
    
60.                 Vector<dimensions> operator/(const double other) const
    
61.                 {
    
62.                         return *this * (1.0 / other);
    
63.                 };
    
64.                 double dot(const Vector<dimensions> &other) const
    
65.                 {
    
66.                         double result = 0;
    
67.                         for (unsigned short index = 0; index < dimensions; index++)
    
68.                         {
    
69.                                 result += this->values[index] * other.values[index];
    
70.                         };
    
71.                         return result;
    
72.                 };
    
73.                 double length() const
    
74.                 {
    
75.                         return sqrt(this->dot(*this));
    
76.                 };
    
77.                 Vector<dimensions> length(const int scale) const
    
78.                 {
    
79.                         return *this / (this->length() / scale);
    
80.                 };
    
81.                 double angle(const Vector<dimensions> &other) const
    
82.                 {
    
83.                         return acos(this->dot(other) / (this->length() * other.length()));
    
84.                 };
    
85. };
    
86. 
    
87. template <>
    
88. class Vector<3>
    
89. {
    
90.         public:
    
91.                 Vector<3> operator*(const Vector<3> &other) const
    
92.                 {
    
93.                         Vector<3> result;
    
94.                         for (unsigned short index = 0; index < 3; index++)
    
95.                         {
    
96.                                 result.values[index] = this->values[(index + 1) % 3] * other.values[(index + 2) % 3] - this->values[(index + 2) % 3] * other.values[(index + 1) % 3];
    
97.                         };
    
98.                         return result;
    
99.                 };
    
100. };

复制代码

我对这个 Vector 进行特化，使其能够完成仅提供三维支持的叉乘，但是编译器报错说在特化中 'const class Vector<3>' has no member named 'values' ，难道特化不保有模板的函数和变量吗？如果不保有，那么怎么修改才能做到减少代码冗余；如果保有，那么这里为什么会报错，又怎么解决？

最佳答案

月排行榜 / 总排行榜

陶远航

2023-10-15 20:12:55

在C++中，模板特化并不保留原模板的成员函数和变量。当你为模板类进行特化时，你实际上是在为特定的模板参数创建一个全新的类定义。这就是为什么在你的特化版本的 Vector<3> 中，编译器无法找到 values 成员的原因。

如果你希望在特化版本中保留一些通用的成员和函数，你可以考虑使用模板类的继承。例如，你可以创建一个基础的 VectorBase 类，然后让 Vector 继承自 VectorBase。这样，你就可以在 VectorBase 中定义通用的成员和函数，然后在 Vector 的特化版本中添加或覆盖特定的成员和函数。

以下是一个简单的示例：

1. template <unsigned short dimensions>
   
2. class VectorBase {
   
3. public:
   
4.     static const unsigned short dimension = dimensions;
   
5.     std::array<double, dimensions> values;
   
6.     // ... 其他通用的成员和函数 ...
   
7. };
   
8. 
   
9. template <unsigned short dimensions>
   
10. class Vector : public VectorBase<dimensions> {
    
11.     // ... 特定的成员和函数 ...
    
12. };
    
13. 
    
14. template <>
    
15. class Vector<3> : public VectorBase<3> {
    
16. public:
    
17.     Vector<3> operator*(const Vector<3> &other) const {
    
18.         Vector<3> result;
    
19.         for (unsigned short index = 0; index < 3; index++) {
    
20.             result.values[index] = this->values[(index + 1) % 3] * other.values[(index + 2) % 3] - this->values[(index + 2) % 3] * other.values[(index + 1) % 3];
    
21.         };
    
22.         return result;
    
23.     };
    
24. };
    

复制代码

这样，Vector<3> 就可以访问 VectorBase<3> 中定义的 values 成员了。同时，你也可以在 Vector<3> 中添加或覆盖特定的成员和函数，以实现三维向量的特殊操作。
请注意，本回答来自GPT-4
如果问题已经解决，请设置最佳答案

跳转到最佳答案楼层

陶远航

在C++中，模板特化并不保留原模板的成员函数和变量。当你为模板类进行特化时，你实际上是在为特定的模板参数创建一个全新的类定义。这就是为什么在你的特化版本的 Vector<3> 中，编译器无法找到 values 成员的原因。

如果你希望在特化版本中保留一些通用的成员和函数，你可以考虑使用模板类的继承。例如，你可以创建一个基础的 VectorBase 类，然后让 Vector 继承自 VectorBase。这样，你就可以在 VectorBase 中定义通用的成员和函数，然后在 Vector 的特化版本中添加或覆盖特定的成员和函数。

以下是一个简单的示例：

1. template <unsigned short dimensions>
   
2. class VectorBase {
   
3. public:
   
4.     static const unsigned short dimension = dimensions;
   
5.     std::array<double, dimensions> values;
   
6.     // ... 其他通用的成员和函数 ...
   
7. };
   
8. 
   
9. template <unsigned short dimensions>
   
10. class Vector : public VectorBase<dimensions> {
    
11.     // ... 特定的成员和函数 ...
    
12. };
    
13. 
    
14. template <>
    
15. class Vector<3> : public VectorBase<3> {
    
16. public:
    
17.     Vector<3> operator*(const Vector<3> &other) const {
    
18.         Vector<3> result;
    
19.         for (unsigned short index = 0; index < 3; index++) {
    
20.             result.values[index] = this->values[(index + 1) % 3] * other.values[(index + 2) % 3] - this->values[(index + 2) % 3] * other.values[(index + 1) % 3];
    
21.         };
    
22.         return result;
    
23.     };
    
24. };
    

复制代码

这样，Vector<3> 就可以访问 VectorBase<3> 中定义的 values 成员了。同时，你也可以在 Vector<3> 中添加或覆盖特定的成员和函数，以实现三维向量的特殊操作。
请注意，本回答来自GPT-4
如果问题已经解决，请设置最佳答案

isdkz

在模板类特化中，只有特化的部分会被编译器处理，其他部分将被忽略。因此，在 Vector<3> 的特化中，只有特化的部分会被编译器处理，而原始模板中的成员变量 values 并不会被保留。

要解决这个问题，可以使用继承来避免代码冗余。首先，将原始模板类中的所有成员函数和变量都放在一个基类中，然后在特化中继承这个基类并添加新的成员函数和变量。这样，特化中就可以使用基类中的成员变量 values 了。

以下是修改后的代码：

1. #include <array>
   
2. #include <cmath>
   
3. 
   
4. template <unsigned short dimensions>
   
5. class VectorBase
   
6. {
   
7. public:
   
8.     static const unsigned short dimension = dimensions;
   
9.     std::array<double, dimensions> values;
   
10.     VectorBase() = default;
    
11.     VectorBase(const VectorBase &) = default;
    
12.     VectorBase(VectorBase &&) = default;
    
13.     VectorBase(std::array<double, dimensions> values)
    
14.     {
    
15.         this->values = values;
    
16.     };
    
17.     VectorBase<dimensions> &operator=(const VectorBase<dimensions> &) = default;
    
18.     VectorBase<dimensions> operator+(const VectorBase<dimensions> &other) const
    
19.     {
    
20.         VectorBase<dimensions> result;
    
21.         for (unsigned short index = 0; index < dimensions; index++)
    
22.         {
    
23.             result.values[index] = this->values[index] + other.values[index];
    
24.         };
    
25.         return result;
    
26.     };
    
27.     VectorBase<dimensions> operator+(const double other) const
    
28.     {
    
29.         VectorBase<dimensions> result;
    
30.         for (unsigned short index = 0; index < dimensions; index++)
    
31.         {
    
32.             result.values[index] = this->values[index] + other;
    
33.         };
    
34.         return result;
    
35.     };
    
36.     VectorBase<dimensions> operator-() const
    
37.     {
    
38.         VectorBase<dimensions> result;
    
39.         for (unsigned short index = 0; index < dimensions; index++)
    
40.         {
    
41.             result.values[index] = -this->values[index];
    
42.         };
    
43.         return result;
    
44.     };
    
45.     VectorBase<dimensions> operator-(const VectorBase<dimensions> &other) const
    
46.     {
    
47.         return (*this) + -other;
    
48.     };
    
49.     VectorBase<dimensions> operator-(const double other) const
    
50.     {
    
51.         return *this + -other;
    
52.     };
    
53.     VectorBase<dimensions> operator*(const double other) const
    
54.     {
    
55.         VectorBase<dimensions> result;
    
56.         for (unsigned short index = 0; index < dimensions; index++)
    
57.         {
    
58.             result.values[index] = this->values[index] * other;
    
59.         };
    
60.         return result;
    
61.     };
    
62.     VectorBase<dimensions> operator/(const double other) const
    
63.     {
    
64.         return *this * (1.0 / other);
    
65.     };
    
66.     double dot(const VectorBase<dimensions> &other) const
    
67.     {
    
68.         double result = 0;
    
69.         for (unsigned short index = 0; index < dimensions; index++)
    
70.         {
    
71.             result += this->values[index] * other.values[index];
    
72.         };
    
73.         return result;
    
74.     };
    
75.     double length() const
    
76.     {
    
77.         return std::sqrt(this->dot(*this));
    
78.     };
    
79.     VectorBase<dimensions> length(const int scale) const
    
80.     {
    
81.         return *this / (this->length() / scale);
    
82.     };
    
83.     double angle(const VectorBase<dimensions> &other) const
    
84.     {
    
85.         return std::acos(this->dot(other) / (this->length() * other.length()));
    
86.     };
    
87. };
    
88. 
    
89. template <unsigned short dimensions>
    
90. class Vector : public VectorBase<dimensions>
    
91. {
    
92. public:
    
93.     using VectorBase<dimensions>::VectorBase;
    
94. };
    
95. 
    
96. template <>
    
97. class Vector<3> : public VectorBase<3>
    
98. {
    
99. public:
    
100.     Vector<3> operator*(const Vector<3> &other) const
     
101.     {
     
102.         Vector<3> result;
     
103.         for (unsigned short index = 0; index < 3; index++)
     
104.         {
     
105.             result.values[index] = this->values[(index + 1) % 3] * other.values[(index + 2) % 3] - this->values[(index + 2) % 3] * other.values[(index + 1) % 3];
     
106.         };
     
107.         return result;
     
108.     };
     
109. };
     

复制代码

在这个修改后的代码中，VectorBase 类包含了原始模板中的所有成员函数和变量，Vector 类和 Vector<3> 类继承了 VectorBase 类并添加了新的成员函数。这样，Vector<3> 就可以使用基类中的成员变量 values 了。

希望这个解决方案能够帮到你！