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

🕗 发布于 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

Redis——分布式锁
为什么要有分布式锁？在只有一台服务器提供服务的情况下，乐观锁和悲观锁足以解决线程并发导致的问题。但是企业开发中避免不了需要部署多台服务器，即采用分布式系统或集群模式，这时，多台服务器就有多个jvm，对
阅读更多2024-09-20
springboot使用minio(8.5.11)
1.配置minio MinioAutoConfiguration 类。3.创建minioTemplate工具类。1.上传时如果流是空的，不上传不成功的。
阅读更多2024-09-20
Redis的Key的过期策略是怎样实现的？
在学习Redis时，我们知道可以设置Key的过期时间，我们还知道，Redis一大特点–。那么当Redis中的数据量起来时，如果直接遍历所有的Key，那么对于Key过期时间的校验应该很费时间，那么Red
阅读更多2024-09-20
电气自动化入门03：安全用电
人体电阻：人体平均电阻：2000欧姆，计算分析时，通常去下线值1700欧姆；2.1 电工知识：触电原因与防触电措施_哔哩哔哩_bilibili。电磁场生理伤害：高频磁场影响人的神经系统；违章冒险
阅读更多2024-09-20
828 华为云征文｜华为 Flexus 云服务器搭建 PicGo 图床
通过在华为 Flexus 云服务器上搭建 PicGo 图床，我们成功地构建了一个高效、稳定的图片存储和管理平台。无论是个人博客、开发者文档还是其他需要图片资源的场景，都能从中受益。在未来，随着需求的不
阅读更多2024-09-20
Pycharm打印区打印数据不全问题
python
阅读更多2024-09-20
git重置本地提交与远程保持一致
【代码】git重置本地提交与远程保持一致。
阅读更多2024-09-20
阿里巴巴拍立淘API返回值：商家优化商品信息的深度指南
阿里巴巴的拍立淘API为商家提供了一个强大的工具，通过其返回值，商家可以深入了解市场竞品，并据此制定有效的商品信息优化策略。通过不断优化商品图片、标题、价格等关键信息，商家可以提升商品的竞争力和市场接
阅读更多2024-09-20
Java入门：09.Java中三大特性（封装、继承、多态）02
比如：类A 继承类BA类称为子类，衍生类，派生类B类称为父类，基类，超类子类自动的拥有父类的所有属性和方法（父类编写，子类不需要再编写）。代码复用目前私有的属性和方法无法访问。多态的基
阅读更多2024-09-20
力扣560 和为k的子数组 Java版本
给你一个整数数组 nums 和一个整数 k ，请你统计并返回该数组中和为 k 的子数组的个数。输入：nums = [1,1,1], k = 2。输入：nums = [1,2,3], k = 3。子数
阅读更多2024-09-20

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

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. 拷贝时编译器的一些优化

相关文章