【C++】隐式转换与explicit关键字、运算符及其重载、this关键字

LAWKAWAI

已于 2023-06-30 20:06:50 修改

阅读量696

点赞数

分类专栏： C++ 文章标签： c++ 开发语言算法

于 2023-05-01 00:19:25 首次发布

本文链接：https://blog.csdn.net/weixin_38362786/article/details/130452957

版权

C++ 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

C++隐式转换与explicit关键字

隐式构造函数

隐含的意思是不会明确告诉你要做什么

隐式转换

C++允许编译器对代码执行一次隐式转换，而不需要使用casr强制转换

例1

#include <iostream>
#include <string>

class Entity
{
private:
 std::string m_Name;
 int m_Age;
public:
 Entity(const std::string& name)
  : m_Name(name), m_Age(-1) {}
 Entity(int age)
  : m_Name("Unknown"), m_Age(age) {}
};
void PrintEntity(const Entity& entity)
{
 // Printing
}
int main()
{
 Entity a("Cherno");
 Entity b(22);

 Entity c = "Cherno";  // 隐式转换
 Entity d = 22;

 PrintEntity(22);
 PrintEntity("Cherno");  // 不能隐式转换，因为"Cherno"不是std::string, 而是一个char数组
 std::cin.get();
}

隐式的将22转换成一个Entity，构造出一个Entity
PrintEntity(22)可以
PrintEntity("Cherno")不可以：
因为"Cherno"不是一个std::string，而是一个char数组，所以要进行两次转换，一次从char数组转换成std::string, 然后再从std::string转换成Entity，然而，只允许做一次隐式转换

PrintEntity(std::string("Cherno"));：
先做一个显式的转换

PrintEntity(Entity("Cherno"));：
或者包含在Entity，因为可以将其隐式地将字符数组转换成std::string

explicit关键字

禁用隐式implicit这个功能
explicit关键字放在构造函数前面，如果有一个explicit构造函数，意味着没有implicit转换。如果要使用整数构造Entity对象，就必须显式调用此构造函数

例2

#include <iostream>
#include <string>

class Entity
{
private:
 std::string m_Name;
 int m_Age;
public:
 Entity(const std::string& name)
  : m_Name(name), m_Age(-1) {}
 explicit Entity(int age)
  : m_Name("Unknown"), m_Age(age) {}
};

void PrintEntity(const Entity& entity)
{
 // Printing
}

int main()
{
 Entity a("Cherno");
 Entity b(22);

 Entity c = "Cherno";  
 Entity d = 22;

 PrintEntity(22);
 PrintEntity("Cherno");  
 PrintEntity(std::string("Cherno"));
  
 std::cin.get();
}

失效：

Entity d = 22;
 PrintEntity(22);

有效：

Entity e = Entity(22);
 Entity f(22);
 Entity g = (Entity)22;

什么时候使用explicit

使用数学库之类的东西，因为不想总是将数字变成向量，确保代码尽量安全

C++运算符及其重载

运算符

一个符号，通常代替一个函数来执行一些事情
dereference运算符->
+=, &, <<
new, delete
, () []

运算符重载

给运算符重载赋予新的含义，添加参数或者创建
允许在程序中定义或更改运算符的行为
运算符重载的使用，应该是非常少

例3

#include <iostream>
#include <string>


struct Vector2
{
 float x, y;
 Vector2(float x, float y)
  : x(x), y(y) {}

 Vector2 Add(const Vector2& other) const
 {
  return Vector2(x + other.x, y + other.y);
 }

 Vector2 Multiply(const Vector2& other) const
 {
  return Vector2(x * other.x, y * other.y);
 }
};
int main()
{
 Vector2 position(4.0f, 4.0f);
 Vector2 speed(0.5f, 1.5f);
 Vector2 powerup(1.1f, 1.1f);
 // 加在一起
 Vector2 result = position.Add(speed.Multiply(powerup));
 std::cin.get();
}

Java只能这样写，因为Java没有操作符重载
可以用this指针:

Vector2 Add(const Vector2& other) const
 {
  return *this + other;
 }

Vector2 Add(const Vector2& other) const
 {
  return operator+(other);
 }

是否可以改成Vector2 result1 = position + speed * powerup;?

例4

#include <iostream>
#include <string>


struct Vector2
{
 float x, y;
 Vector2(float x, float y)
  : x(x), y(y) {}

 Vector2 Add(const Vector2& other) const
 {
  return Vector2(x + other.x, y + other.y);
  // return *this + other;
 }

 Vector2 operator+(const Vector2& other) const
 {
  return Add(other);
 }
 
 Vector2 Multiply(const Vector2& other) const
 {
  return Vector2(x * other.x, y * other.y);
 }

 Vector2 operator*(const Vector2& other) const
 {
  return Multiply(other);
  // return *this + other;
 }
};

int main()
{
 Vector2 position(4.0f, 4.0f);
 Vector2 speed(0.5f, 1.5f);
 Vector2 powerup(1.1f, 1.1f);
 // 加在一起
 Vector2 result = position.Add(speed.Multiply(powerup));

 Vector2 result1 = position + speed * powerup;   // +运算符重载了


 std::cin.get();
}

运算符+和*都进行了重载

<< 操作符

std::cout << result2 << std::endl; //

<< 操作符没有被重载，接收两个参数，一个是输出流cout,另一个是Vector2

例5

#include <iostream>
#include <string>


struct Vector2
{
 float x, y;
 Vector2(float x, float y)
  : x(x), y(y) {}

 Vector2 Add(const Vector2& other) const
 {
  return Vector2(x + other.x, y + other.y);
  // return *this + other;
 }

 Vector2 operator+(const Vector2& other) const
 {
  return Add(other);
 }
 
 Vector2 Multiply(const Vector2& other) const
 {
  return Vector2(x * other.x, y * other.y);
 }

 Vector2 operator*(const Vector2& other) const
 {
  return Multiply(other);
  // return *this + other;
 }
 std::ostream& operator<<(std::ostream& stream, const Vector2& other)
{
 stream << other.x << "," << other.y;
 return stream;
}
};
int main()
{
 Vector2 position(4.0f, 4.0f);
 Vector2 speed(0.5f, 1.5f);
 Vector2 powerup(1.1f, 1.1f);
 // 加在一起
 Vector2 result = position.Add(speed.Multiply(powerup));

 Vector2 result1 = position + speed * powerup;   // +, * 运算符重载了
 std::cout << result << std::endl;   // << 操作符重载了

 std::cin.get();
}

==操作符

例6

#include <iostream>
#include <string>


struct Vector2
{
 float x, y;
 Vector2(float x, float y)
  : x(x), y(y) {}

 Vector2 Add(const Vector2& other) const
 {
  return Vector2(x + other.x, y + other.y);
  // return *this + other;
 }

 Vector2 operator+(const Vector2& other) const
 {
  return Add(other);
 }
 
 Vector2 Multiply(const Vector2& other) const
 {
  return Vector2(x * other.x, y * other.y);
 }

 Vector2 operator*(const Vector2& other) const
 {
  return Multiply(other);
  // return *this + other;
 }
 std::ostream& operator<<(std::ostream& stream, const Vector2& other)
{
 stream << other.x << "," << other.y;
 return stream;
}
bool operator==(const Vector2& other) const
 {
  return x == other.x && y == other.y;
 }
};
int main()
{
 Vector2 position(4.0f, 4.0f);
 Vector2 speed(0.5f, 1.5f);
 Vector2 powerup(1.1f, 1.1f);
 // 加在一起
 Vector2 result1 = position.Add(speed.Multiply(powerup));
 Vector2 result12 = position.Add(speed.Multiply(powerup));

 Vector2 result1 = position + speed * powerup;   // +, * 运算符重载了
 std::cout << result2 << std::endl;   // << 操作符重载了
if (result1 == result2)      // == 操作符重载了
 {  
 }
 std::cin.get();
}

!=操作符

例7

#include <iostream>
#include <string>


struct Vector2
{
 float x, y;
 Vector2(float x, float y)
  : x(x), y(y) {}

 Vector2 Add(const Vector2& other) const
 {
  return Vector2(x + other.x, y + other.y);
  // return *this + other;
 }

 Vector2 operator+(const Vector2& other) const
 {
  return Add(other);
 }
 
 Vector2 Multiply(const Vector2& other) const
 {
  return Vector2(x * other.x, y * other.y);
 }

 Vector2 operator*(const Vector2& other) const
 {
  return Multiply(other);
  // return *this + other;
 }
 std::ostream& operator<<(std::ostream& stream, const Vector2& other)
{
 stream << other.x << "," << other.y;
 return stream;
}
bool operator==(const Vector2& other) const
 {
  return x == other.x && y == other.y;
 }
 bool operator!=(const Vector2& other) const
 {
  return !(*this == other);
  // return !operator==(other);
 }
};
int main()
{
 Vector2 position(4.0f, 4.0f);
 Vector2 speed(0.5f, 1.5f);
 Vector2 powerup(1.1f, 1.1f);
 // 加在一起
 Vector2 result1 = position.Add(speed.Multiply(powerup));
 Vector2 result12 = position.Add(speed.Multiply(powerup));

 Vector2 result1 = position + speed * powerup;   // +, * 运算符重载了
 std::cout << result2 << std::endl;   // << 操作符重载了
if (result1 == result2)      // == 操作符重载了
 {  
 }
 if (result1 != result2)      // != 操作符重载了
 {  
 }
 std::cin.get();
}

C++的this关键字

通过它，可以访问成员函数，即属于某个类的函数
this是一个指向当前对象实例的指针，该方法属于这个对象实例
可以写一个方法，非静态方法，为了调用这个方法，首先需要实例化一个对象，然后调用这个方法；这个方法必须用一个有效的对象来调用，关键字this是指向该对象的指针

例8

#include <iostream>
#include <string>

class Entity
{
public:
 int x, y;

 Entity(int x, int y)
 {
  this->x = x;
  this->y = y;
 }

 int GetX() const
 {
  const Entity* e = this;  // this必须是const的
 }
};
int main()
{
 std::cin.get();
}

this是const Entity const 类型：
在这里插入图片描述

在类外调用函数，可以使用this：

例9

#include <iostream>
#include <string>

void PrintEntity(Entity* e);

class Entity
{
public:
 int x, y;

 Entity(int x, int y)
 {
  this->x = x;
  this->y = y;

  PrintEntity(this);
 }

 int GetX() const
 {
  const Entity* e = this;  // this必须是const的
 }
};


void PrintEntity(Entity* e)
{
 // Printing
}

int main()
{
 std::cin.get();
}

void PrintEntity(const Entity& e);

Entity& e = *this;
  PrintEntity(this);

void PrintEntity(const Entity& e)
{
 // Printing
}

int GetX() const
 {
  const Entity& e = *this;  // this必须是const的
 }