类和对象——相关的零碎知识

🕗 发布于 2024-07-23 14:45 c++ c语言 算法

前提提示：
其实C++中的类和对象，最重要的是6个默认函数，如有忘记，请移步到：类和对象。本章是对于一些细节知识的补充和拓展。

1. 隐示类型转换

在运算时，运算符左右两边的操作数的类型不同，编译器是会按照类型转换的要求，将两个操作数的类型转换为一样，然后就行运算。

1.1 内置类型的隐示类型转换

我们的内置类型，他们之间出现类型不一致的情况时，是有一套类型转换的规则的，但是还有自定义类型，内置类型和自定义类型之间是如何转化？
答：这个其实和我们的前面将的构造函数有关了，其实在类型转换的时候，我们可以很容易的发现，被类型转化的变量其实没有改变，但是确确实实有实现了运算，就是因为隐示类型转换的时候，产生了临时变量，临时变量存储着变量类型转换之后的结果。

#include<iostream>
using namespace std;

int main()
{
double b = 1.223;
int a = b;
cout << a << " " << b << endl;

return 0;
}

在这里插入图片描述
程序的执行逻辑：

这串代码实际上就是可以反映出，在隐示类型转换时，产生了临时变量。如果不产生临时变量，那么输出的结果是：1 1，但输出的结果是1 1.223 ，就说明产生了临时变量。

1.2 自定义类型的隐示类型转换

解释：这里的自定义类型的隐示类型转换，是指内置类型想自定义类型转换，自定义类型是无法想内置类型转换的。同时不同的自定义类型之间也是不能互相类型转换的。

#include<iostream>
using namespace std;

class A
{
public:
//构造函数
A(int a)
:x(a),
y(a)
{
cout << "A(int a)" << endl;
};

void operator=(A&a)
{
x = a.x;
y = a.y;
cout << "void operator=(A&a)" << endl;
}

private:
int x;
int y;
};


int main()
{
int a = 6;
A tmp = a;
return 0;
}

上述程序中的两个变量 a和tmp的类型不相同，那他们是怎么进行隐示类型转换的呢？这个就需要和之前的初始化列表联系起来了，因为这个转换需要使用到类的6个默认函数中的连续构造函数和拷贝构造，程序的执行逻辑如下。
在这里插入图片描述
程序输出的结果：

为什么上面讲的是先连续构造然后拷贝构造，为什么程序在执行的时候只进行了普通的构造？这是因为编译器的优化。编译器将连续构造+拷贝构造优化为直接构造，这样更加的节省空间和时间。但是我们也发现其实这样的隐示类型转换时十分依赖于构造函数的书写的。
当将构造函数修改为如下：

class A
{
public:
//构造函数
A(int a=0,int b=5)
:x(b),
y(b)
{
cout << "A(int a)" << endl;
cout << x << "  " << y << endl;
};

A(const A&a)
{
x = a.x;
y = a.y;
cout << "A(A&a)" << endl;
}

private:
int x;
int y;
};


int main()
{
int a = 6;
A tmp = a;

return 0;
}

输出的结果：
在这里插入图片描述
当构造函数与需要类型转换的内置类型变量无关时。上面的例子就是，虽然传入了a但是没有使用a对类中的成员变量初始化，而是使用b的缺省值进行初始化，这时虽然将int类型转换为A类型但是是与a无关的。
进阶：
上面在演示程序逻辑时，a变量作为实参，去匹配构造函数的参数列表时，并没有说参数的数量，实际上a不只是能匹配一个参数的构造函数，还可以匹配多个参数的构造函数（其他第一个参数，其他的参数都需要有缺省值才行）。其实自定义的类型的隐示类型转换就是通过直接构造函数完成的，那能不能传入多个不同的类型转化为自定义类型？

class A
{
public:
//构造函数
A(int a,int b)
:x(a),
y(b)
{
cout << "A(int a)" << endl;
cout << x << "  " << y << endl;
};
private:
int x;
int y;
};
int main()
{
int a = 6;
int b = 7;
A tmp = {a,b};
return 0;
}

程序运行的结果：

结论：
1.并不是只能一个类型进行隐示类型转换，多个类型也是可以隐示类型转换的，多个类型隐示类型转换的步骤和上面一样，只是这次向构造函数的传参不是一个。
2.构造函数不仅可以构造和初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

1.2.1 explicit关键字

上面讲了自定义类型的隐示类型转换是通过构造函数来完成隐示类型转换，当我们不允许隐示类型转换时，会在构造函数前面加上explicit这个关键字。

class A
{
public:
//构造函数
explicit A(int a,int b)
:x(a),
y(b)
{
cout << "A(int a)" << endl;
cout << x << "  " << y << endl;
};
private:
int x;
int y;
};
int main()
{
int a = 6;
int b = 7;
A tmp = {a,b};
return 0;
}

这段程序是报错的，原因就是在构造函数前面加上了explicit关键字，还进行了隐示类型转换。

2. Static关键字

2.1 Static类成员

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量。
特性：

静态成员为所有的类型共有，放在静态区。
静态成员变量只创建一次，静态成员变量必须在类的外面定义，定义是不加static关键字。
静态成员变量可以使用:类名：静态成员或者对象.静态成员访问。
静态成员变量也是类型的成员，是受到public，private和protect的保护的。

代码演示

class A
{
public:
//构造函数
    A(int a,int b)
:x(a),
y(b)
{
cout << "A(int a)" << endl;
cout << x << "  " << y  << endl;
};
private:
int x;
int y;
static int c;
};
int A:: c = 5;
int main()
{
int a = 6;
int b = 7;
A tmp = {a,b};
return 0;
}

2.2 Static修饰成员函数

用static修饰的成员函数，称之为静态成员函数

特性：

静态成员函数被static修饰，没有this指针，只能访问静态成员变量。
静态成员函数是不在成员函数存储的地方的。

代码演示：

class A
{
public:
//构造函数
A(int a, int b)
: x(a),
y(b)
{
};

static int get()
{
return c;
}
private:
int x;
int y;
//静态成员变量的声明
static int c;
};
//静态成员变量的定义
int A:: c = 5;
int main()
{
int a = 6;
int b = 7;
A tmp = {a,b};
cout << tmp.get() << endl;;
return 0;
}

输出的结果：
在这里插入图片描述

3. const修饰

const放在成员函数的参数括号的后面，这个const是用来修饰*this指针的，是为了不让通过this指针修改类中的成员变量。如：const *this

代码演示：

class A
{
public:
//构造函数
A(int a, int b)
: x(a),
y(b)
{
cout << "x=" << x <<"  " << "y=" << y << endl;
};
//const修饰的成员函数
void get()const
{
//这个是不能修改类中的成员变量的
x = 4;
y = 5;
}
private:
int x;
int y;
static int c;
};

代码结果：
这个代码是报错的
在这里插入图片描述

4. 友元类和友元函数

4.1 友元函数

友元函数可以直接访问类的私有成员变量，它的定义是在类的外面的普通函数，不属于任何类，但是需要在类中声明，声明时需要加friend关键字。

特性：

友元函数可以访问私有和保护成员变量
友元函数没有this指针，所有不能const修饰
友元函数可以在类的任何位置进行声明，不受访问限定符的限制
一个函数可以是多个类的友元函数
友元函数和普通函数的调用是一样的

代码演示：

#include<iostream>
using namespace std;
class A
{
public:
//构造函数
A(int a, int b)
: x(a),
y(b)
{
cout << "x=" << x <<"  " << "y=" << y << endl;
};
friend void get(int& n, int& m, const A& wa);
private:
int x;
int y;
static int c;
};
int A:: c = 5;

void get(int& n,int& m,const A& wa)
{
n = wa.x;
m = wa.y;

}
int main()
{
int a = 6;
int b = 7;
A tmp = {a,b};
int n, m;
get(n, m, tmp);
cout << "n=" << n << "  "<<"m=" << m << endl;

return 0;
}

代码运行结果：
在这里插入图片描述
**结论：**当我们在类的外部定义的普通函数需要使用类中的成员变量时，就可以在该类中声明友元函数，这个该普通函数就可以访问类中的成员变量。

4.2 友元类

有一个类是另一个类的友元类，该类型中的成员函数都另一个类的友元函数，该类的成员函数都可以访问另一个类的非公有成员变量。

特性：

友元关系是单向的，比如：A是B的友元类，A是可以访问B中的成员变量，但是B不是A的友元，B是不可以访问A中的成员变量的。
友元关系是不能传递的，A是B的友元，B是C的友元，这并不意味这A是C的友元。
友元关系是不能继承的。

代码演示：

#include<iostream>
using namespace std;

class A
{
public:
//构造函数
A(int a, int b)
: x(a),
y(b)
{
cout << "x=" << x <<"  " << "y=" << y << endl;
};
friend class B;
private:
int x;
int y;
static int c;
};
class B
{
public:

int get(const A& a)
{
return a.x;
}

};
int A:: c = 5;
int main()
{
int a = 6;
int b = 7;
A tmp = {a,b};
B tm;
int n = tm.get(tmp);
cout << n << endl;

return 0;
}

代码运行的结果：
在这里插入图片描述

5. 内部类

概念：一个类定义在另一个类的内部，就称该类是另一个类的内部类。

特性：

内部类和外部类是平等的，内部类虽然在外部类中定义，但是内部类是不属于外部类的，sizeof(外部类)是不会算上内部类的。
内部类是外部类的友元类，他们之间遵循友元关系的定义和用法，但是外部类不是内部类的友元。
内部类可以定义在外部类的任何位置。
内部类是可以直接访问外部类中的static成员变量的，不需要加上对象名/类名。
虽然说内部类和外部类是平等的，但是内部类需要定义是需要通过外部类的。

代码演示：

#include<iostream>
using namespace std;

class A
{
public:
//构造函数
A(int a, int b)
: x(a),
y(b)
{
cout << "x=" << x <<"  " << "y=" << y << "  " << "c=" << c << endl;
};
class B
{
public:

int get(A& a)
{
return c;
}

};
private:
int x;
int y;
static int c;
};

int A:: c = 5;

int main()
{
int a = 6;
int b = 7;
A tmp = {a,b};
A::B p;
cout << p.get(tmp) << endl;

return 0;
}

代码的运行结果：
在这里插入图片描述

6. 匿名对象

特性

匿名对象是不需要取名字的
匿名对象的生命周期只有它定义的这一行

代码演示：

#include<iostream>
using namespace std;
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
int main()
{
A();
return 0;
}

程序运行的结果：
在这里插入图片描述

7. 拷贝时编译器的一些优化

连续构造+拷贝构造直接优化为直接构造。
连续拷贝构造+拷贝构造直接优化为拷贝构造。
连续拷贝+赋值重载是没有办法进行优化的。

原文地址：https://blog.csdn.net/Mrlossry/article/details/140616771

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：matlab 声音信号希尔伯特黄变换
下一篇：零基础学SpringBoot(一)--初识SpringBoot

学生公寓管理系统
由于某些特殊原因，需要对学生当前入住的床位进行修改时，使用此功能。新生开学后，宿管管理可以先根据学生所在系查询该专业预定的宿舍和具体的床位入住状态信息，为该学生分配一个空闲状态的床位，并修改当前床位状
阅读更多2024-11-15
Windows上安装RabbitMQ 4.0.3教程
通过上述步骤，你应该已经成功在Windows上安装了RabbitMQ 4.0.3，并启用了管理插件。现在，你可以开始使用RabbitMQ来构建你的分布式系统了。希望这篇教程对你有所帮助，如果有任何问题
阅读更多2024-11-15
【蓝桥等考C++真题】蓝桥杯等级考试C++组第13级L13真题原题(含答案)-成绩排序
C++L13 成绩排序(50 分)
阅读更多2024-11-15
Web入门
HTTP（HyperText Transfer Protocol，超文本传输协议）是一种应用层协议。主要用于在Web浏览器和服务器之间传输数据。基于TCP协议：面向连接，确保了数据传输的可靠性和顺序。
阅读更多2024-11-15
Android 最新的AndroidStudio引入依赖失败如何解决？如:Failed to resolve:xxxx
在引入依赖时报错：Failed to resolve: xxx.xxxx:1.1.0。
阅读更多2024-11-15
力扣113：路径总和II
力扣113：路径总和II。C语言
阅读更多2024-11-15
【springboot使用sqlite数据库】Java后台同时使用mysql、sqlite
根据业务的需要，老版程序使用的数据库是sqlite，版本升级成前后台分离模式，因此需要兼容mysql与sqlite数据库同时使用。
阅读更多2024-11-15
力扣.15 三数之和 three-sum
这道题作为 leetcode 的第 15 道题，看起来似曾相识。大概思路可以有下面几种：暴力解法数组排序+二分Hash 优化双指针。
阅读更多2024-11-15
力扣第 53 题：最大子数组和
题目给定一个整数数组nums，目标是找到和最大的连续子数组（最少包含一个元素），并返回其和。例如，在数组中，和最大的子数组为，其和为6。
阅读更多2024-11-15
linux-缓冲区
调用系统调用接口是需要时间成本的，如果使用缓冲区，存储的字符串到一定长度再调用系统调用，能够有效减少调用系统调用的次数。这个缓冲区是语言设置的，缓冲区满足条件就用系统调用接口write将缓冲区的内容刷
阅读更多2024-11-15

类和对象——相关的零碎知识

1. 隐示类型转换

1.1 内置类型的隐示类型转换

1.2 自定义类型的隐示类型转换

1.2.1 explicit关键字

2. Static关键字

2.1 Static类成员

2.2 Static修饰成员函数

3. const修饰

4. 友元类和友元函数

4.1 友元函数

4.2 友元类

5. 内部类

6. 匿名对象

7. 拷贝时编译器的一些优化

相关文章