如何重载运算符而不是同时使用 "Curiously Recurring Template Pattern" 和 "Run Time polymorphism"
How to overload operators and not to use both "Curiously Recurring Template Pattern" and "Run Time polymorphism"
我只想overload + and = operators
在"Number"class.
我想要两个childclass一个。 Integer B. Fraction,实现了"Number" class
。目前下面是我的代码的样子。但是这里我使用的是both Static and Run time polymorphism paradigm
。如何避免?
代码片段:
人数class:
template<class T>
class Number
{
virtual T& operator= (const T &) = 0;
virtual const T operator+ (const T &) = 0;
virtual void display(std::ostream &) = 0;
};
整数Class:
// operator "=" overloading
Integer& Integer::operator=(const Integer &secondNumber)
{
intValue = secondNumber.intValue;
return *this;
}
// operator "+" overloading
const Integer Integer::operator+(const Integer &secondNumber)
{
Integer temp;
temp.intValue = this->intValue + secondNumber.intValue;
return temp;
}
此外,如果我从我的 "Number" class 中删除 "template" 我不能重载 + 运算符,因为它 returns class 实例,我们不能abstract class 的一个实例,它是 "Number class"
此外,如果我不能去掉 virtual 关键字,因为我希望我的 child 实现 "Number class" 中存在的方法。
请在这里稍微指导一下是否有任何方法可以在代码中同时使用两种类型的范式,即静态和动态。
您需要决定您更喜欢哪种方法,以及为什么您只想使用一种方法。但是我在你的代码中没有看到编译时多态性,你只是在创建一个通用模板的多个实例。这两个实例没有任何共同点,除非它们也继承了一个公共接口。
关于决定使用哪种方法,而不是看你打算从代码中得到什么,我发现:你需要决定你不需要或可能不需要的功能包含在您的设计中。
这是一个非常有限的要点列表,这些可能是好是坏取决于你的情况:
编译时多态性。
- 高效;不需要虚拟调用,编译器可以很好地优化代码。
- 非常严格(没有基本定义的虚函数):没有派生实现,繁荣,没有编译。
- 基础对象(从动态的角度来看)并不常见,但为模板实例化所独有。
- 混合大量实例化会产生很大的开销(您也可以进一步抽象您的设计以减轻这种情况)。
动态多态。
- 唯一 (派生) 类型包含一个公共接口。
- 一旦使用基指针或引用,就可以放松一些优化(如果需要,编译时方法可以内联当前源中定义明确且可用的所有内容)。
- 除非虚函数是纯函数:没有实现,不用担心,没有错误(编译时,您将不得不发现 运行 时的错误)。
我可以根据您的 Number
class 假设您不需要混合类型数组 (Number<int>
& Number<float>
)。如果是这种情况,编译时解决方案可能是合适的。但是,如果你想创建一个可以对任何形式的 Number
进行操作的函数,那么你将不得不从 Number
中删除模板,或者也将函数实现为模板(可能以代码结尾每个 T
).
重复
U用更具体的需求更新您的问题,正确的方法或组合将更加明显。我也会更新这个答案。
我的大部分观点都来自于使用嵌入式系统。需要考虑系统功能才能做出明确的决定。如果能在不影响用户体验的情况下掠夺资源,让代码变得非常抽象和肉眼混乱可能并不值得。
我只想
overload + and = operators
在"Number"class.我想要两个childclass一个。 Integer B. Fraction,实现了
"Number" class
。目前下面是我的代码的样子。但是这里我使用的是both Static and Run time polymorphism paradigm
。如何避免?
代码片段:
人数class:
template<class T>
class Number
{
virtual T& operator= (const T &) = 0;
virtual const T operator+ (const T &) = 0;
virtual void display(std::ostream &) = 0;
};
整数Class:
// operator "=" overloading
Integer& Integer::operator=(const Integer &secondNumber)
{
intValue = secondNumber.intValue;
return *this;
}
// operator "+" overloading
const Integer Integer::operator+(const Integer &secondNumber)
{
Integer temp;
temp.intValue = this->intValue + secondNumber.intValue;
return temp;
}
此外,如果我从我的 "Number" class 中删除 "template" 我不能重载 + 运算符,因为它 returns class 实例,我们不能abstract class 的一个实例,它是 "Number class"
此外,如果我不能去掉 virtual 关键字,因为我希望我的 child 实现 "Number class" 中存在的方法。
请在这里稍微指导一下是否有任何方法可以在代码中同时使用两种类型的范式,即静态和动态。
您需要决定您更喜欢哪种方法,以及为什么您只想使用一种方法。但是我在你的代码中没有看到编译时多态性,你只是在创建一个通用模板的多个实例。这两个实例没有任何共同点,除非它们也继承了一个公共接口。
关于决定使用哪种方法,而不是看你打算从代码中得到什么,我发现:你需要决定你不需要或可能不需要的功能包含在您的设计中。
这是一个非常有限的要点列表,这些可能是好是坏取决于你的情况:
编译时多态性。
- 高效;不需要虚拟调用,编译器可以很好地优化代码。
- 非常严格(没有基本定义的虚函数):没有派生实现,繁荣,没有编译。
- 基础对象(从动态的角度来看)并不常见,但为模板实例化所独有。
- 混合大量实例化会产生很大的开销(您也可以进一步抽象您的设计以减轻这种情况)。
动态多态。
- 唯一 (派生) 类型包含一个公共接口。
- 一旦使用基指针或引用,就可以放松一些优化(如果需要,编译时方法可以内联当前源中定义明确且可用的所有内容)。
- 除非虚函数是纯函数:没有实现,不用担心,没有错误(编译时,您将不得不发现 运行 时的错误)。
我可以根据您的 Number
class 假设您不需要混合类型数组 (Number<int>
& Number<float>
)。如果是这种情况,编译时解决方案可能是合适的。但是,如果你想创建一个可以对任何形式的 Number
进行操作的函数,那么你将不得不从 Number
中删除模板,或者也将函数实现为模板(可能以代码结尾每个 T
).
U用更具体的需求更新您的问题,正确的方法或组合将更加明显。我也会更新这个答案。
我的大部分观点都来自于使用嵌入式系统。需要考虑系统功能才能做出明确的决定。如果能在不影响用户体验的情况下掠夺资源,让代码变得非常抽象和肉眼混乱可能并不值得。