派生类中的成员模板函数

最新推荐文章于 2022-12-08 13:36:56 发布
原创 最新推荐文章于 2022-12-08 13:36:56 发布 · 1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#iostream #struct #include #class #gcc

博客给出一段C++代码示例，定义了基类和派生类，派生类中有模板成员函数。代码在main函数中进行了不同类型转换操作，并展示了代码在vc.net、gcc、icc编译器下的运行结果，指出派生类中的模板成员会隐蔽基类的同名函数。
#include <iostream>

using namespace std;

struct base
{
  virtual operator int()
  {
    return 1;
  }
 
  virtual ~base() {}
};

struct derive : public base
{
  template <class _Ty>
  operator _Ty()
  {
    return _Ty();
  }
};

int main()
{
  derive cd;
  base & cb = cd;
 
  int i = cd;
  cout << i << "/n";
 
  i = cd.derive::operator int();
  cout << i << "/n";
 
  i = cb;
  cout << i << "/n";
 
  double d = cd;
  cout << d << "/n";
}

vc.net: 1 1 1 0
gcc： 1 0 1 1 
icc： 0 0 1 0

派生类中的模板成员把基类的同名函数隐蔽了（即便是还未具现化)(保留)
C++模板元编程（17）成员函数模板和模板类的继承
二进制君
04-21 3699
模板类的继承包括四种： 1.普通类继承模板类 大家要区分模板类和类模板的概念，模板类是类模板具体化后得到的类。 template<class T> class Base { public: Base(T data) : data_(data) {} private: T data_; }; class Derived: public Base<int> { public: Derived(int data) : Base<int>(data) {}
C++函数模板（模板函数）详解
我不是码农的博客~~~
08-08 3278
定义 函数模板不是一个实在的函数，编译器不能为其生成可执行代码。定义函数模板后只是一个对函数功能框架的描述，当它具体执行时，将根据传递的实际参数决定其功能。（好吧，咱也听不懂，直接上用法吧?） 用法： 面向对象的继承和多态机制有效提高了程序的可重用性和可扩充性。在程序的可重用性方面，程序员还希望得到更多支持。举一个最简单的例子，为了交换两个整型变量的值，需要写下面的 Swap 函数： void Swap(int & x, int & y) { int tmp = x; x =
模板类派生
MeetingParis的博客
04-01 320
//从模板类派生一个普通类#include&lt;iostream&gt; using namespace std; template&lt;typename T&gt; class A { public: A(T a = 0) { this-&gt;a = a; } public: void printA() { cout &lt;&lt; "a:" &lt;&lt; a ...
C/C++编程：派生和类模板
OceanStar的博客
04-20 814
类模板可以继承也可以被继承。一般模板和非目标的继承没有什么区别。然而，要从依赖型名称所引用的基类派生一个类模版的情况下，这两者之间有一个重要的区别。让我们来看个例子 非依赖型基类 ...
类模板及派生
qq_26860179的博客
08-24 1542
类模板及派生 （一） 模板主要有两大类：即函数模板和类模板。这里主要讲一下对类模板的理解。 模板书面上讲就是一种对类型进行参数化的工具，那么类模板就是对“类”这种类型进行参数化的工具（也可以理解为一种类的轮廓，不限制类里面参数的类型）。再打一个通俗的比方：假设类就是月饼，而类模板就是生产月饼的机器，当然月饼有很多种类，比如长的，方的，（等价于数据类型或者类中成员函数返回值类型就是整型、浮点型
根据模板参数生成派生类
神探
10-23 911
Base.h //根据模板参数生成派生类 #ifndef BASE_H_ #define BASE_H_ #include using namespace std; class CBase { public: CBase(){} ~CBase(){} void BaseMethod() { cout<<"BaseMethod in Base"<<endl; } };
『C/C++养成计划』解读类的继承和派生！
AI新视界
08-29 704
解读C++字符串对象string！ 文章目录1. 字符串对象1.1. 字符串对象的定义和初始化1.2. 字符串对象的引用1.3. 字符串对象的输入和输出1.4. 字符串对象与C风格字符串的转换1.5. string的一些操作 1. 字符串对象 C++为字符串提供了一种新的自定义类型：字符串类string。采用类来实现字符串，具有如下特点： ①采用动态内存管理，不必担心存储空间是否足够，甚至都不用有字符数组的概念； ②能够检测和控制诸如越界之类的异常，提高使用的安全性； ③封装字符串多种处理操作，功能增
C++ 模板类成员在派生类中的调用
Mr_scott_j的博客
10-06 415
以从Graph类派生出的UndiGraph类为例： class Graph//基类 { protected: int maxVertexes; int Vertex_num; int Edge_num; bool Weight; bool Directed; bool Vertex_value; public: //static const E maxWeight = INF; Graph(int size = 30); Graph(const
C++模板类的公有派生类成员函数内部使用基类公有成员函数的方法
weixin_45716046的博客
06-24 324
在基类公有成员函数之前加入模板基类域名 ```cpp #include<iostream> using namespace std; template<class T> class a { public: void funA(); }; template<class T> void a<T>::funA() { cout << "A "; } template<class T> class b :public a<T
C++模板类中，派生类使用基类中数据或方法报“找不到标识符”
星辰的博客
09-29 2254
若构造的类为模板类，那么派生类不可以直接使用继承到的基类数据和方法，需要通过this指针使用。
p187：普通类能派生出模板类，模板类也能派生出基类
sinat_41619762的博客
03-14 534
书上的这个例子就是普通类派生出模板类： /* 基类 */ struct __slist_node_base { __slist_node_base* next; } /* 派生类 */ template <class T> struct __slist_node : public __slist_node_base { T data; }; 下面是一个模板类派生出普通类的例子： template <class T> struct __slist_node_base {
类模板与派生
江南又一春
12-12 524
概述 类模板从类模板派生 类模板从模板类派生 类模板从普通类派生 普通类从模板类派生 1、类模板从类模板派生 template <class T1,class T2> class A { T1 v1; T2 v2; }; template <class T1,class T2> class B:public A<T2,T1> { T1 v3; T2 v4...
C++学习14：C++类模板
12-08 1186
C++类模板
【C++】（二十六）类的继承与派生
weixin_44378835的博客
11-04 3100
文章目录类的继承与派生1 基类与派生类2 派生类的定义3 派生类的构成 类的继承与派生 1 基类与派生类 继承（inheritance）是面向对象程序设计的一个重要特性，是软件复用（software reusability）的一种重要形式。 继承允许在原有类的基础上创建新的类，新类可以从一个或多个原有类中继承数据成员和成员函数，并且可以重新定义或增加新的成员，从而形成类的层次。继承具有传递性，不仅支持系统的可重用性，而且还促进系统的可扩充性。 类的对象是各自封闭的，如果没继承性机制，则类对象中数据、函数就
C++类模板派生类模板
chen_zan_yu_的博客
01-29 1054
#include "pch.h" #include &lt;iostream&gt; using namespace std; template&lt;class T&gt; class Animal { public: void Jiao() { cout &lt;&lt; mAge &lt;&lt; "岁的动物在叫!" &lt;&lt; endl; } public
派生类中的static成员
一路向北
02-27 616
理论知识 基类定义的静态成员，将被所有派生类共享 根据静态成员自身的访问特性和派生类的继承方式，在类层次体系中具有不同的访问性质 （遵守派生类的访问控制） 派生类中访问静态成员，用以下形式显式说明： 类名 :: 成员 或通过对象访问 对象名 . 成员 代码如下: #include <iostrea...
区分“派生类对象”和“派生类”对基类成员的访问权限
u012223598的专栏
08-13 4363
1.“派生类对象”和“派生类”对基类成员的访问权限
派生类成员的访问
yuer的博客
06-07 718
在一个派生类中，对继承于基类的数据成员以及成员函数的访问依赖于成员访问限定符以及继承方式两者的影响。 由protected声明的成员从用户的角度看，等价于私有成员。但实际上和私有成员有一点不同，就是说保护成员可以被派生类成员函数引用。 派生类成员的访问属性，这部分主要需要解决两个问题，如下： 1. 派生类的成员函数访问继承自基类的成员 2. 基类的成
类成员函数模板是否可以特化返回值
最新发布
08-27
<think>我们正在讨论C++中类成员函数模板的特化问题，特别是关于返回值类型的特化。 根据C++标准，函数模板（包括成员函数模板）是支持全特化的，这意味着我们可以为特定的模板参数提供专门的实现，包括对返回值类型的特化。 但是，请注意以下几点： 1. 函数模板（包括成员函数模板）不能进行偏特化（部分特化），只能全特化。这是C++的语法规定。 2. 当我们特化一个成员函数模板时，特化的是整个函数，包括返回值类型和参数类型。也就是说，我们可以为特定的模板参数提供不同的返回值类型和函数体。 因此，对于类成员函数模板，我们可以特化返回值类型，但必须同时指定所有模板参数（即全特化），并且特化后的函数签名（包括返回值类型和参数列表）可以与原模板不同。 示例： 假设我们有一个类，其中包含一个成员函数模板： ```cpp class MyClass { public: template <typename T> T process(T value); // 成员函数模板 }; ``` 我们可以为特定的类型（比如int）特化这个成员函数模板，并改变其返回值类型： ```cpp template <> double MyClass::process<int>(int value) { // 特化版本：当T=int时，返回double // 函数实现 return static_cast<double>(value) / 2.0; } ``` 注意：上面的特化中，我们指定了模板参数为`int`，但是函数的返回值类型改为了`double`，这是允许的。 但是，这里有一个重要的点：特化版本的函数签名（函数名和参数类型）必须与原始模板实例化后的签名匹配吗？实际上，特化版本的参数类型必须与原始模板在特化参数下的实例化类型相同，但返回值类型可以不同。 然而，上面的例子中，参数类型是`int`（因为T被指定为int，所以参数类型是`int`，与原始模板中`T process(T value)`在T=int时的参数类型一致），而返回值类型我们改成了`double`。 但是，请注意：在调用时，调用方式必须与特化的版本匹配。例如： ```cpp MyClass obj; double result = obj.process<int>(5); // 必须显式指定模板参数为int，因为参数5是int，但如果不指定，模板参数推导会得到T=int，然后匹配特化版本，但返回值是double，所以需要赋值给double类型变量 ``` 或者，如果我们不显式指定模板参数，让编译器推导： ```cpp int x = 5; auto result = obj.process(x); // 这里T被推导为int，所以调用特化版本，返回double类型 ``` 但是，如果我们将返回值赋值给int变量，则会发生隐式转换： ```cpp int y = obj.process(x); // 调用特化版本（返回double），然后转换为int ``` 因此，特化成员函数模板的返回值类型是允许的，但需要谨慎使用，以避免类型不匹配的问题。 另外，需要注意的是，特化必须在同一个命名空间作用域中定义，且不能在类定义内部。 但是，有一个限制：我们不能对函数模板进行偏特化（例如，只特化返回值类型而不特化所有模板参数，或者只特化部分模板参数）。如果我们想实现类似偏特化的效果，可以使用重载或者SFINAE技术，或者通过类模板来间接实现（因为类模板支持偏特化）。 总结：类成员函数模板可以全特化，包括改变返回值类型，但不能进行偏特化。 下面是一个完整的示例代码： ```cpp #include <iostream> #include <typeinfo> class Printer { public: template <typename T> T print(T value) { std::cout << "通用版本: " << value << std::endl; return value; } }; // 特化版本：当T为int时，返回double template <> double Printer::print<int>(int value) { std::cout << "特化版本（int->double）: " << static_cast<double>(value) << std::endl; return static_cast<double>(value); } int main() { Printer p; auto result1 = p.print(3.14); // 调用通用版本，返回double auto result2 = p.print(100); // 调用特化版本，返回double // 打印结果类型 std::cout << "result1的类型: " << typeid(result1).name() << std::endl; // 应为double std::cout << "result2的类型: " << typeid(result2).name() << std::endl; // 应为double // 注意：也可以显式指定模板参数 double r = p.print<int>(200); // 调用特化版本 return 0; } ``` 注意：在特化版本中，我们改变了返回值类型为double，而原始模板中返回值类型是T。在特化版本中，我们返回double，所以当T=int时，函数返回double。 但是，在调用时，如果我们不显式指定模板参数，编译器会根据实参类型推导模板参数。对于整数100，编译器推导T为int，因此调用特化版本，返回double。 另外，关于特化的语法，我们必须在类外部定义特化，并且以`template<>`开头。 最后，需要提醒的是，函数模板特化（包括成员函数模板特化）不如函数重载直观，有时使用重载可能更清晰。例如，我们可以通过添加一个重载的非模板成员函数来实现类似的效果（但注意，类成员函数的重载规则与非成员函数不同，且不能添加非模板函数来重载模板函数，除非参数类型不同）。但是，如果我们需要改变返回值类型，重载可能无法做到（因为重载要求函数名相同而参数不同，而返回值类型不参与重载决策）。因此，在这种情况下，特化是可行的解决方案。 所以，答案是肯定的：类成员函数模板可以特化返回值类型，通过全特化实现。</think>在 C++ 中，类成员函数模板可以特化返回值类型，但需要通过**全特化**实现，且必须同时指定所有模板参数。以下是具体实现方法和注意事项： ### 一、成员函数模板返回值特化的实现 ```cpp class ValueProcessor { public: // 通用成员函数模板 template <typename T> T compute(T input) { std::cout << "通用版本返回值: " << typeid(T).name() << "\n"; return input; } }; // 全特化：针对 int 类型输入，返回 double 类型 template <> double ValueProcessor::compute<int>(int input) { std::cout << "特化版本: int->double\n"; return static_cast<double>(input) * 1.5; } // 使用示例 ValueProcessor vp; auto result1 = vp.compute(10); // 调用特化版本，返回 double auto result2 = vp.compute(3.14); // 调用通用版本，返回 double auto result3 = vp.compute("abc");// 调用通用版本，返回 const char* ``` ### 二、关键语法要点 1. **全特化要求** 必须使用 `template<>` 声明全特化，并显式指定所有模板参数： ```cpp template <> ReturnType ClassName::FunctionName<SpecificType>(Params) {...} ``` 2. **返回值类型自由** 特化版本的返回值类型可以与原始模板不同： ```cpp // 原始模板返回 T，特化版本返回 double template <> double MyClass::process<int>(int value) {...} ``` 3. **参数类型匹配** 参数类型必须与原始模板在特化类型下的签名**完全一致**： ```cpp template <typename T> T func(T param); // 原始模板 // 正确：参数类型匹配 T=int template <> double func<int>(int param); // 错误：参数类型不匹配 template <> double func<int>(double param); ``` ### 三、重要限制与替代方案 1. **不支持偏特化** 无法仅特化返回值而保留其他模板参数（函数模板不支持偏特化）： ```cpp // 错误：尝试偏特化返回值 template <typename U> double process<int, U>(int value); ``` 2. **替代方案：类模板特化** 通过类模板偏特化实现更灵活的类型控制： ```cpp template <typename T> struct Processor { auto compute(T input) { /* 通用实现 */ } }; // 针对 int 的偏特化 template <> struct Processor<int> { double compute(int input) { /* 返回 double */ } }; ``` 3. **C++20 概念简化** 使用概念约束避免显式特化： ```cpp template <typename T> auto compute(T input) { if constexpr (std::integral<T>) { return static_cast<double>(input) * 1.5; } else { return input; } } ``` ### 四、使用场景与最佳实践 1. **类型转换场景** 当需要对特定类型进行特殊转换时： ```cpp template <> std::string Serializer::serialize<Image>(Image img) { return img.to_base64(); // 返回 string 而非 Image } ``` 2. **接口适配场景** 统一接口但返回不同派生类型： ```cpp template <> std::unique_ptr<Derived> Factory::create<Base>() { return std::make_unique<Derived>(); } ``` 3. **性能优化场景** 避免不必要的类型转换开销： ```cpp template <> float Matrix::determinant<float>() { // 优化版浮点运算 } ``` > **关键原则**：函数模板特化应保持语义一致性，返回值类型变化不应破坏调用方预期行为[^3][^4]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值