C++：模板运算算符重载

于 2024-07-22 22:15:00 发布
阅读量558 收藏 11
点赞数 7
分类专栏： C++ 文章标签： c++ 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43441284/article/details/140422667
版权

模板运算符重载函数

运算符重载+



template <typename T, typename T1>
class People;

template <typename T, typename T1>
void myprint(const People<T, T1>& pn);
template <typename T, typename T1>
class People {
 private:
  /* data */
  int age;

 public:
  People() : age(0) {}  // Default constructor
  People(int a) : age(a) {}

  //运算符重载+ -
  People<T, T1> operator+(People<T, T1>& other);

  friend void myprint<T, T1>(const People<T, T1>& pn);
};
template <typename T, typename T1>
People<T, T1> People<T, T1>::operator+(People<T, T1>& other) {
  cout << "operator+ :" << endl;
  People<T, T1> tmp;
  tmp.age = this->age + other.age;
  return tmp;
}

template <typename T, typename T1>
void myprint(const People<T, T1>& pn) {
  cout << "a friend fun" << endl;
  cout << "pn.age=" << pn.age << endl;
}

void test070802(void) {
  People<int, int> p1(1);
  myprint(p1);

  People<int, int> p2(11);
  myprint(p2);

  People<int, int> p3(77);
  p3 = p1 + p2;

  myprint(p3);
}

运算符重载+=

template <typename T, typename T1>
class People;

template <typename T, typename T1>
void myprint(const People<T, T1>& pn);
template <typename T, typename T1>
class People {
 private:
  /* data */
  int age;

 public:
  People() : age(0) {}  // Default constructor
  People(int a) : age(a) {}

  //运算符重载+
  People<T, T1> operator+(People<T, T1>& other);

  //运算符重载 +=
  People<T, T1> operator+=(People<T, T1>& other);

  friend void myprint<T, T1>(const People<T, T1>& pn);
};
template <typename T, typename T1>
People<T, T1> People<T, T1>::operator+=(People<T, T1>& other) {
  cout << "operator+= :" << endl;
  this->age = this->age + other.age;
  return *this;
}

template <typename T, typename T1>
People<T, T1> People<T, T1>::operator+(People<T, T1>& other) {
  cout << "operator+ :" << endl;
  People<T, T1> tmp;
  tmp.age = this->age + other.age;
  return tmp;
}

template <typename T, typename T1>
void myprint(const People<T, T1>& pn) {
  cout << "a friend fun" << endl;
  cout << "pn.age=" << pn.age << endl;
}

void test070802(void) {
  People<int, int> p1(1);
  myprint(p1);

  People<int, int> p2(11);
  myprint(p2);

  People<int, int> p3(77);
  p3 = p1 + p2;

  myprint(p3);

  People<int, int> p4(99);
  p4 += p1;

  myprint(p4);
}

模板友元运算符重载实现

+作为友元运算符重载
(1)友元函数在class内实现，ok，但是因为是友元实现的，所以参数要有2个

template <typename T, typename T1>
class People;

template <typename T, typename T1>
void myprint(const People<T, T1>& pn);
template <typename T, typename T1>
class People {
private:
/* data */
int age;

public:
People() : age(0) {} // Default constructor
People(int a) : age(a) {}

//运算符重载+
friend People<T, T1> operator+(People<T, T1>& a, const People<T, T1>& b) {
cout << “friend operator+ :” << endl;
People<T, T1> tmp;
tmp.age = a.age + b.age;
return tmp;
}

//运算符重载 +=
People<T, T1> operator+=(People<T, T1>& other);

friend void myprint<T, T1>(const People<T, T1>& pn);
};
template <typename T, typename T1>
People<T, T1> People<T, T1>::operator+=(People<T, T1>& other) {
cout << “operator+= :” << endl;
this->age = this->age + other.age;
return *this;
}

template <typename T, typename T1>
void myprint(const People<T, T1>& pn) {
cout << “a friend fun” << endl;
cout << “pn.age=” << pn.age << endl;
}

void test070802(void) {
People<int, int> p1(1);
myprint(p1);

People<int, int> p2(11);
myprint(p2);

People<int, int> p3(77);
p3 = p1 + p2;

myprint(p3);
}

(2)友元函数在class外实现，OK



template <typename T, typename T1>
class People;

template <typename T, typename T1>
void myprint(const People<T, T1>& pn);

template <typename T, typename T1>
People<T, T1> operator+(People<T, T1>& a, People<T, T1>& b);


template <typename T, typename T1>
class People {
 private:
  /* data */
  int age;

 public:
  People() : age(0) {}  // Default constructor
  People(int a) : age(a) {}

  //运算符重载+
  friend People<T, T1> operator+<T, T1>(People<T, T1>& a, People<T, T1>& b);

  //运算符重载 +=
  People<T, T1> operator+=(People<T, T1>& other);

  friend void myprint<T, T1>(const People<T, T1>& pn);
};


// Define the friend operator+ within the header file
template <typename T, typename T1>
People<T, T1> operator+(People<T, T1>& a, People<T, T1>& b) {
  cout << "friend operator+ :" << endl;
  People<T, T1> tmp;
  tmp.age = a.age + b.age;
  return tmp;
}

template <typename T, typename T1>
People<T, T1> People<T, T1>::operator+=(People<T, T1>& other) {
  cout << "operator+= :" << endl;
  this->age = this->age + other.age;
  return *this;
}

template <typename T, typename T1>
void myprint(const People<T, T1>& pn) {
  cout << "a friend fun" << endl;
  cout << "pn.age=" << pn.age << endl;
}

void test070802(void) {
  People<int, int> p1(1);
  myprint(p1);

  People<int, int> p2(11);
  myprint(p2);

  People<int, int> p3(77);
  p3 = p1 + p2;

  myprint(p3);
}

(3)友元函数的第三种实现，ok

template <typename T, typename T1>
class People;

template <typename T, typename T1>
void myprint(const People<T, T1>& pn);




template <typename T, typename T1>
class People {
 private:
  /* data */
  int age;

 public:
  People() : age(0) {}  // Default constructor
  People(int a) : age(a) {}

  //运算符重载+
 template <typename A, typename A1> friend People<A, A1> operator+(People<A, A1>& a, People<A, A1>& b);

  //运算符重载 +=
  People<T, T1> operator+=(People<T, T1>& other);

  friend void myprint<T, T1>(const People<T, T1>& pn);
};


// Define the friend operator+ within the header file
template <typename T, typename T1>
People<T, T1> operator+(People<T, T1>& a, People<T, T1>& b) {
  cout << "friend operator+ :" << endl;
  People<T, T1> tmp;
  tmp.age = a.age + b.age;
  return tmp;
}

template <typename T, typename T1>
People<T, T1> People<T, T1>::operator+=(People<T, T1>& other) {
  cout << "operator+= :" << endl;
  this->age = this->age + other.age;
  return *this;
}

template <typename T, typename T1>
void myprint(const People<T, T1>& pn) {
  cout << "a friend fun" << endl;
  cout << "pn.age=" << pn.age << endl;
}

void test070802(void) {
  People<int, int> p1(1);
  myprint(p1);

  People<int, int> p2(11);
  myprint(p2);

  People<int, int> p3(77);
  p3 = p1 + p2;

  myprint(p3);
}

+=作为友元运算符重载
(1)友元函数在class内实现，ok，但必须带2个参数，带1个不行



template <typename T, typename T1>
class People;

template <typename T, typename T1>
void myprint(const People<T, T1>& pn);

template <typename T, typename T1>
class People {
 private:
  /* data */
  int age;

 public:
  People() : age(0) {}  // Default constructor
  People(int a) : age(a) {}

  //运算符重载+
  template <typename A, typename A1>
  friend People<A, A1> operator+(People<A, A1>& a, People<A, A1>& b);

  //运算符重载 +=
  friend People<T, T1> operator+=(People<T, T1>& a, People<T, T1>& b) {
    cout << "friend operator+= :" << endl;
    a.age = a.age + b.age;
    return a;
  }

  friend void myprint<T, T1>(const People<T, T1>& pn);
};

// Define the friend operator+ within the header file
template <typename T, typename T1>
People<T, T1> operator+(People<T, T1>& a, People<T, T1>& b) {
  cout << "friend operator+ :" << endl;
  People<T, T1> tmp;
  tmp.age = a.age + b.age;
  return tmp;
}

template <typename T, typename T1>
void myprint(const People<T, T1>& pn) {
  cout << "a friend fun" << endl;
  cout << "pn.age=" << pn.age << endl;
}

void test070802(void) {
  People<int, int> p1(1);
  myprint(p1);

  People<int, int> p2(11);
  myprint(p2);

  People<int, int> p3(77);
  p3 += p1;

  myprint(p3);
}

(2)友元函数在class外实现，ok



template <typename T, typename T1>
class People;

template <typename T, typename T1>
void myprint(const People<T, T1>& pn);

template <typename T, typename T1>
People<T, T1> operator+=(People<T, T1>& a, People<T, T1>& b);

template <typename T, typename T1>
class People {
 private:
  /* data */
  int age;

 public:
  People() : age(0) {}  // Default constructor
  People(int a) : age(a) {}

  //运算符重载+
  template <typename A, typename A1>
  friend People<A, A1> operator+(People<A, A1>& a, People<A, A1>& b);

  //运算符重载 +=
  friend People<T, T1> operator+=<T, T1>(People<T, T1>& a, People<T, T1>& b);

  friend void myprint<T, T1>(const People<T, T1>& pn);
};
//运算符重载 +=
template <typename T, typename T1>
People<T, T1> operator+=(People<T, T1>& a, People<T, T1>& b) {
  cout << "friend operator+= :" << endl;
  a.age = a.age + b.age;
  return a;
}
// Define the friend operator+ within the header file
template <typename T, typename T1>
People<T, T1> operator+(People<T, T1>& a, People<T, T1>& b) {
  cout << "friend operator+ :" << endl;
  People<T, T1> tmp;
  tmp.age = a.age + b.age;
  return tmp;
}

template <typename T, typename T1>
void myprint(const People<T, T1>& pn) {
  cout << "a friend fun" << endl;
  cout << "pn.age=" << pn.age << endl;
}

void test070802(void) {
  People<int, int> p1(1);
  myprint(p1);

  People<int, int> p2(11);
  myprint(p2);

  People<int, int> p3(77);
  p3 += p1;

  myprint(p3);
}

(3)友元函数的第三种实现，ok



template <typename T, typename T1>
class People;

template <typename T, typename T1>
void myprint(const People<T, T1>& pn);



template <typename T, typename T1>
class People {
 private:
  /* data */
  int age;

 public:
  People() : age(0) {}  // Default constructor
  People(int a) : age(a) {}

  //运算符重载+
  template <typename A, typename A1>
  friend People<A, A1> operator+(People<A, A1>& a, People<A, A1>& b);

  //运算符重载 +=
  template <typename B, typename B1> friend People<B, B1> operator+=(People<B, B1>& a, People<B, B1>& b);

  friend void myprint<T, T1>(const People<T, T1>& pn);
};
//运算符重载 +=
template <typename T, typename T1>
People<T, T1> operator+=(People<T, T1>& a, People<T, T1>& b) {
  cout << "friend operator+= :" << endl;
  a.age = a.age + b.age;
  return a;
}
// Define the friend operator+ within the header file
template <typename T, typename T1>
People<T, T1> operator+(People<T, T1>& a, People<T, T1>& b) {
  cout << "friend operator+ :" << endl;
  People<T, T1> tmp;
  tmp.age = a.age + b.age;
  return tmp;
}

template <typename T, typename T1>
void myprint(const People<T, T1>& pn) {
  cout << "a friend fun" << endl;
  cout << "pn.age=" << pn.age << endl;
}

void test070802(void) {
  People<int, int> p1(1);
  myprint(p1);

  People<int, int> p2(11);
  myprint(p2);

  People<int, int> p3(77);
  p3 += p1;

  myprint(p3);
}

学习记录，侵权联系删除。
来源：朱老师物联网大课堂

li星野
关注
  • 7
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++重载与模板
希望我的博客，能帮上你解决学习中工作中所遇到的问题
01-17 243
重载与模板 包含模板的函数匹配规则： •候选函数包括所有模板实参推断成功的函数模板实例 c++ •template <typename T> string debug_rep(const T &t) {...} •template <typename T> string debug_rep(T *p) {...} •​​string s("hi"); //第二个模板实参推断失败，所以调用第一个模板； •cout << debug_rep(s) &lt
C++中运算符重载的规则语法实例
12-25
①、 C++中的运算符除了少数几个之外，全部可以重载，而且只能重载C++中已有的运算符。  不能重载的运算符只有五个，它们是：成员运算符“.”、指针运算符“*”、作用域运算符“：：”、“sizeof”、条件运算符...
C++模板重载
yoco的博客
09-15 1343
C++模板重载 产生背景：需要多个对不同类型使用同一种算法函数时可以使用模板，但是并非所有的类型都使用同一种算法，为了解决这个问题，产生了模板重载。 Tips： 1.如同函数的重载一样，模板重载函数的特征标必须不同 2.并非所有的模板参数都必须是模板参数类型 显示具体化（explicit specialization）：提供一个具体化函数定义 基于（ISO/ANSI C++标准） C++98标准选择的方法： 1.对于给定的函数名，可以有非模板函数、模板函数和显示具体化模板函数以及它们的重载版本 2.显示具体
C++类模板的重载
weixin_41111116的博客
11-12 2018
C++类模板的重载
C++函数模板重载
Tan_HandSome的博客
11-14 575
直接上代码   #include&lt;iostream&gt; using namespace std; template &lt;class T&gt; void print(T a) { cout &lt;&lt; "first\n"&lt;&lt;a &lt;&lt; endl; } template&lt;typename T&gt; void print(T a, T b) {
C++函数模板的重载
luoganttcc的博客
11-17 375
#include <iostream> using namespace std; template<class T> void Swap(T &a, T &b); //模板①：交换基本类型的值 template<typename T> void Swap(T a[], T b[], int len); //模板②：交换两个数组 void printArray(int arr[], int len); //打印数组元素 int main(){
c++运算符重载矩阵运算.pdf
10-20
C++运算符重载矩阵运算 本文档主要介绍了使用C++语言对矩阵类Matrix进行运算符重载，实现矩阵的加、减、乘、转置、赋值运算。通过对Matrix类的设计和实现，实现了矩阵的基本运算操作。 一、问题分析和任务定义 在...
c++运算符重载矩阵运算
06-12
例如，重载加运算符可以实现矩阵的加法运算，重载减运算符可以实现矩阵的减法运算，重载乘运算符可以实现矩阵的乘法运算，重载转置运算符可以实现矩阵的转置运算，重载赋值运算符可以实现矩阵的赋值运算。...
C++运算符重载友元函数实例
08-17
在C++编程语言中，运算符重载是允许我们为已存在的运算符赋予新的含义或功能的一种机制。这个实例将探讨如何通过成员函数和非成员函数两种...通过练习和理解这些例子，你将更好地掌握C++中运算符重载和友元函数的使用。
C++_模板函数重载
weixin_50183638的博客
08-25 1361
C++_模板函数重载
C++重载函数及重载函数模板的使用
06-22
（1）输人并运行所给的参考程1，并将程序中的注释部分也输人计算机，体会和理解程序的基本格式规范。 （2）编写一个函数把华氏温度转换为摄氏温度，转换公式为C= (F一32)＊5/9。 （3）编写重载函数Maxl可分别求取两个整数，三个整数，两个双精度数，三个双精度数的最大值。 （4）使用重载函数模板重新实现上小题中的函数Maxl。 （5）使用系统函数pow(x,y)计算xy的值，注意包含头文件math.h。 （6）用递归的方法编写函数求Fibonacci级数，观察递归调用的过程。
C++模板与模板的重载
JAN6055的博客
01-15 594
C++泛型
c++模板的重载与特例化
li_unit的博客
09-15 392
//重载与模板 //函数模板可以被另一个或普通非模版函数重载，名字相同的函数必须具有不同数量或类型的参数 template<typenameT> stringdebug_rep(constT&) {/**/} template<typenameT> stringdebug_rep(T*p) {/**/} stringdebug_rep(co...
实验13 运算符重载2与函数模板
weixin_62431082的博客
10-28 161
附加题没写，参考代码在最下。
C++函数模版调用重载函数模版
KingEasternSun的专栏
03-26 1128
对于两个不同的重载函数，两个之间可以互相调用,如下代码 void testoveride(std::string s){ std::cout<<s<<std::ends; } void testoveride(std::vector s){ testoveride(s.at(1)); } std::vector s; s.push_back(std::string("1"
模板函数+运算符的重载
a266676的博客
06-26 418
#include<iostream> using namespace std; #define SIZE 5 class complex { public: int real; int imag; public: inline int complex::operator <(const complex &c) ...
C++模板函数重载规则细说
最新发布
红军不怕远征难，万水千山只等闲
12-25 1983
文章真的长呀，如果你能坚持看到这里，说明你是一个非常坚持且对编程有强烈兴趣的人，希望这篇文章让你在c++模板的路上有所帮助。那么接下来我们再来回顾一下这篇文章的内容。我们先介绍了模板元编程要解决的场景与问题然后我们从一个具体的模板元编程例子展开，一步步学习了模板元编程的整体内容接下来针对其核心：模板函数重载匹配规则以及模板规则进一步了解最后再给出在使用方面的一些经验供参考模板元编程他要解决的最核心的问题就是：对模板类型的判断与选择。
【c++模板笔记一】模板的介绍及其重载
zmyouknow的专栏
02-11 1852
本文你将学到： 1.为什么要引入模板。 2.怎么去定义和使用模板 3.分析模板的实现方法和隐式推断规则。 4.模板重载的规则。
C++编程：位运算与移位操作解析
- **函数**：讲解了函数的定义、使用，以及相关的特性，如内联函数、默认参数、重载函数和函数模板。 - **类与对象**：作为面向对象编程的核心，类和对象的使用、构造函数、析构函数、组合、类模板等是重点内容。 - ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

li星野

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值