为什么要使用类型运算符重载？
- 当你需要给对象里面的一个数据成员单独赋一个值时；
- 当你需要获取成员函数的返回值 或者 获取类中的一个数据成员的值时；
- 当你需要从一个对象赋值给另一个不同类的对象时；
类型运算符重载有哪几种形式？
- 普通类型 ==> 类类型
- 类类型 ==> 普通类型
- 类类型A ==> 类类型B
一、普通类型 ==> 类类型
他是一个普通的数据类型转换为类中的一个数据成员，并赋值给他。
需求：
- 定义一个Boy类，根据Boy类定义出对象boy1 和 boy2；
- 给boy1 里面的 salary 赋值 39000， 给boy2 里面的 name 赋值 “张三”；
- 打印结果出来。
代码示例：
Boy.h
#pragma once
#include <iostream>
#include <string>
class Boy {
public:
Boy(char *name=NULL, int age=0, int salary=0);
~Boy();
// 普通类型 ==> 类类型
// 需求：
//1. 定义一个Boy类，根据Boy类定义出对象boy1 和 boy2；
//2. 给boy1 里面的 salary 赋值 39000， 给boy2 里面的 name 赋值 “张三”；
//3. 打印结果出来。
Boy(int salary);
Boy(const char *name); // 注意：指针必须使用const类型修饰
// 输出方法
std::string description() const;
private:
char *name;
int age;
int salary;
};
Boy.cpp
#include <sstream>
#include "Boy.h"
Boy::Boy(char *name, int age, int salary) {
if (!name) {
name = "无名";
}
this->name = new char[strlen(name)+1];
strcpy_s(this->name, strlen(name)+1, name);
this->age = age;
this->salary = salary;
}
Boy::~Boy() {
if (name) {
delete[] name;
}
}
Boy::Boy(int salary) {
char *defaultName = "无名";
this->name = new char[strlen(defaultName)+1];
strcpy_s(this->name, strlen(defaultName)+1, defaultName);
this->age = 0;
this->salary = salary;
}
Boy::Boy(const char *name) {
this->name = new char[strlen(name)+1];
strcpy_s(this->name, strlen(name)+1, name);
this->age = 0;
this->salary = 0;
}
std::string Boy::description() const {
std::stringstream ret;
ret << "姓名：" << name << "\t年龄：" << age << "\t薪资：" << salary;
return ret.str();
}
main
#include <iostream>
#include "Boy.h"
// 普通类型 ==> 类类型
// 需求：
//1. 定义一个Boy类，根据Boy类定义出对象boy1 和 boy2；
//2. 给boy1 里面的 salary 赋值 39000， 给boy2 里面的 name 赋值 “张三”；
//3. 打印结果出来。
using namespace std;
int main(void) {
Boy boy1 = 39000;
Boy boy2 = "张三";
cout << boy1.description() << endl;
cout << boy2.description() << endl;
system("pause");
return 0;
}
运行截图：
二、类类型 ==> 普通类型
他是一个将类类型中的数据成员和方法转化为普通的类型，并赋值给普通的数据变量。
类类型 ==> 普通类型
需求：
- 定义一个Boy类，根据Boy类定义出对象boy1(“张三”, 21, 45000)；
- 定义一个方法score，用于计算张三的（薪资乘以年龄再除以3）并返回；
- main函数中定义一个普通的数据成员int类型变量用于获取score方法中的返回数据；
- 将boy1对象中的name数据成员赋值给一个普通的数据成员char *name；
- 打印结果出来。
代码实例：
Boy.h
#pragma once
#include <iostream>
#include <string>
class Boy {
public:
Boy(char *name=NULL, int age=0, int salary=0);
~Boy();
// 普通类型 ==> 类类型
// 需求：
//1. 定义一个Boy类，根据Boy类定义出对象boy1 和 boy2；
//2. 给boy1 里面的 salary 赋值 39000， 给boy2 里面的 name 赋值 “张三”；
//3. 打印结果出来。
//Boy(int salary);
//Boy(const char *name);
/***************************************************************************/
// 类类型 ==> 普通类型
// 需求：
//1. 定义一个Boy类，根据Boy类定义出对象boy1("张三", 21, 45000)；
//2. 定义一个方法score，用于计算张三的（薪资乘以年龄再除以3）并返回；
//3. main函数中定义一个普通的数据成员int类型变量用于获取score方法中的返回数据；
//4. 将boy1对象中的name数据成员赋值给一个普通的数据成员char *name；
//5. 打印结果出来
// 特殊的运算符重载：类型转换函数，不需要写返回类型
operator int() const;
operator char *() const;
int score() const;
// 输出方法
std::string description() const;
private:
char *name;
int age;
int salary;
};
Boy.cpp
#include <sstream>
#include "Boy.h"
Boy::Boy(char *name, int age, int salary) {
if (!name) {
name = "无名";
}
this->name = new char[strlen(name)+1];
strcpy_s(this->name, strlen(name)+1, name);
this->age = age;
this->salary = salary;
}
Boy::~Boy() {
if (name) {
delete[] name;
}
}
// 普通类型 ==> 类类型
//Boy::Boy(int salary) {
// char *defaultName = "无名";
//
// this->name = new char[strlen(defaultName)+1];
// strcpy_s(this->name, strlen(defaultName)+1, defaultName);
//
// this->age = 0;
// this->salary = salary;
//}
//
//Boy::Boy(const char *name) {
// this->name = new char[strlen(name)+1];
// strcpy_s(this->name, strlen(name)+1, name);
//
// this->age = 0;
// this->salary = 0;
//}
/***************************************************************************/
// 类类型 ==> 普通类型
Boy::operator int() const {
return score();
}
Boy::operator char *() const {
return name;
}
int Boy::score() const {
return salary * age / 3;
}
std::string Boy::description() const {
std::stringstream ret;
ret << "姓名：" << name << "\t年龄：" << age << "\t薪资：" << salary;
return ret.str();
}
main
#include <iostream>
#include "Boy.h"
// 类类型 ==> 普通类型
// 需求：
//1. 定义一个Boy类，根据Boy类定义出对象boy1("张三", 21, 45000)；
//2. 定义一个方法score，用于计算张三的（薪资乘以年龄再除以3）并返回；
//3. main函数中定义一个普通的数据成员int类型变量用于获取score方法中的返回数据；
//4. 将boy1对象中的name数据成员赋值给一个普通的数据成员char *name；
//5. 打印结果出来。
using namespace std;
int main(void) {
/*Boy boy1 = 39000;
Boy boy2 = "张三";
cout << boy1.description() << endl;
cout << boy2.description() << endl;*/
/***************************************************************************/
Boy boy1("张三", 21, 45000);
int score = boy1; // score();
char *name = boy1; // "张三"
cout << "score:" << score << endl;
cout << "name:" << name << endl;
cout << boy1.description() << endl;
system("pause");
return 0;
}
运行截图：
三、类类型A ==> 类类型B
他是可以将不同类的对象赋值给另一个类的对象
Boy boy(“张三”, 21, 45000)；
Man man = boy;
类类型A ==> 类类型B
需求：
- 定义一个Boy类，根据Boy类定义出对象boy(“张三”, 21, 45000)；
- 定义一个Man类，根据Man类定义出对象man，并将对象boy赋值给man（Man man = boy;）；
- 打印结果出来。
下面代码中会用到 输出运算符重载 ；如果有不懂的朋友可以点击链接去了解一下，会有详细介绍：
https://blog.youkuaiyun.com/cpp_learner/article/details/104262877
代码示例：
Boy.h
#pragma once
#include <iostream>
#include <string>
class Man;
class Boy {
public:
Boy(char *name=NULL, int age=0, int salary=0);
~Boy();
// 普通类型 ==> 类类型
// 需求：
//1. 定义一个Boy类，根据Boy类定义出对象boy1 和 boy2；
//2. 给boy1 里面的 salary 赋值 39000， 给boy2 里面的 name 赋值 “张三”；
//3. 打印结果出来。
//Boy(int salary);
//Boy(const char *name);
/***************************************************************************/
// 类类型 ==> 普通类型
// 需求：
//1. 定义一个Boy类，根据Boy类定义出对象boy1("张三", 21, 45000)；
//2. 定义一个方法score，用于计算张三的（薪资乘以年龄再除以3）并返回；
//3. main函数中定义一个普通的数据成员int类型变量用于获取score方法中的返回数据；
//4. 将boy1对象中的name数据成员赋值给一个普通的数据成员char *name；
//5. 打印结果出来
// 特殊的运算符重载：类型转换函数，不需要写返回类型
/*operator int() const;
operator char *() const;
int score() const;*/
/***************************************************************************/
// 类类型A ==> 类类型B
// 需求：
//1. 定义一个Boy类，根据Boy类定义出对象boy("张三", 21, 45000)；
//2. 定义一个Man类，根据Man类定义出对象man，并将对象boy赋值给man（Man man = boy;）；
//3. 打印结果出来。
char *getName() const;
int getAge() const;
int getSalary() const;
// 输出方法
std::string description() const;
private:
char *name;
int age;
int salary;
};
Boy.cpp
#include <sstream>
#include "Boy.h"
Boy::Boy(char *name, int age, int salary) {
if (!name) {
name = "无名";
}
this->name = new char[strlen(name)+1];
strcpy_s(this->name, strlen(name)+1, name);
this->age = age;
this->salary = salary;
}
Boy::~Boy() {
if (name) {
delete[] name;
}
}
// 普通类型 ==> 类类型
//Boy::Boy(int salary) {
// char *defaultName = "无名";
//
// this->name = new char[strlen(defaultName)+1];
// strcpy_s(this->name, strlen(defaultName)+1, defaultName);
//
// this->age = 0;
// this->salary = salary;
//}
//
//Boy::Boy(const char *name) {
// this->name = new char[strlen(name)+1];
// strcpy_s(this->name, strlen(name)+1, name);
//
// this->age = 0;
// this->salary = 0;
//}
/***************************************************************************/
// 类类型 ==> 普通类型
//Boy::operator int() const {
// return score();
//}
//
//Boy::operator char *() const {
// return name;
//}
//
//int Boy::score() const {
// return salary * age / 3;
//}
/***************************************************************************/
char *Boy::getName() const {
return name;
}
int Boy::getAge() const {
return age;
}
int Boy::getSalary() const {
return salary;
}
std::string Boy::description() const {
std::stringstream ret;
ret << "姓名：" << name << "\t年龄：" << age << "\t薪资：" << salary;
return ret.str();
}
Man.h
#pragma once
#include <iostream>
using namespace std;
class Boy;
class Man {
public:
Man(char *name=NULL, int age=0, int salary=0, int coefficient=0);
// 类类型A ==> 类类型B
Man(const Boy &boy);
~Man(void);
private:
char *name;
int age;
int salary;
int coefficient; // 系数
// 将Man的输出运算符重载定义为友元
friend ostream &operator<<(ostream &os, Man &man);
};
// 声明Man的输出运算符重载
ostream &operator<<(ostream &os, Man &man);
Man.cpp
#include "Man.h"
#include "Boy.h"
Man::Man(char *name, int age, int salary, int coefficient) {
if (!name) {
name = "无名";
}
this->name = new char[strlen(name)+1];
strcpy_s(this->name, strlen(name)+1, name);
this->age = age;
this->salary = salary;
this->coefficient = coefficient;
}
Man::~Man(void) {
if (name) {
delete[] name;
}
}
Man::Man(const Boy &boy) {
int len = strlen(boy.getName())+1;
this->name = new char[len];
strcpy_s(this->name, len, boy.getName());
this->age = boy.getAge();
this->salary = boy.getSalary();
this->coefficient = 0;
}
// Man的输出运算符重载实现
ostream &operator<<(ostream &os, Man &man) {
os << "姓名：" << man.name << "\t年龄：" << man.age << "\t薪资：" << man.salary << "\t系数：" << man.coefficient;
return os;
}
main
#include "Boy.h"
#include "Man.h"
// 类类型A ==> 类类型B
// 需求：
//1. 定义一个Boy类，根据Boy类定义出对象boy("张三", 21, 45000)；
//2. 定义一个Man类，根据Man类定义出对象man，并将对象boy赋值给man（Man man = boy;）；
//3. 打印结果出来。
int main(void) {
/*Boy boy1 = 39000;
Boy boy2 = "张三";
cout << boy1.description() << endl;
cout << boy2.description() << endl;*/
/***************************************************************************/
//Boy boy1("张三", 21, 45000);
//int score = boy1; // score();
//char *name = boy1; // "张三"
//cout << "score:" << score << endl;
//cout << "name:" << name << endl;
//cout << boy1.description() << endl;
/***************************************************************************/
Boy boy("张三", 21, 45000);
Man man = boy;
cout << "boy:" << boy.description() << endl;
cout << "man:" << man << endl;
system("pause");
return 0;
}
运行截图：
总结：
类型运算符重载其实不难，只要区分好三个的区别，记住他们的定义和用法；
-
普通类型 ==> 类类型
定义：
Boy(int salary);
Boy(const char *name); // 注意：指针必须使用const类型修饰
他也可以说是构造函数重载
当你需要给对象里面的一个数据成员单独赋一个值时； -
类类型 ==> 普通类型
定义：
// 特殊的运算符重载：类型转换函数，不需要写返回类型
operator int() const;
operator char *() const;
当你需要获取成员函数的返回值 或者 获取类中的一个数据成员的值时； -
类类型A ==> 类类型B
定义：
Man(const Boy &boy);
当你需要从一个对象赋值给另一个不同类的对象时；
1万+
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
