封装—类和对象

已于 2022-08-11 14:04:06 修改
阅读量145 收藏
点赞数
文章标签： c++ 算法 开发语言
于 2022-07-28 17:55:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xiehanhust/article/details/126017633
版权

1. 从C到C++——const

const int m = 10
int n = m
在C中：编译器先从m所在的内存处取数据，再赋值给n
在C++中：编译器会直接将10赋给n，没有读取内存的过程，等价于int n = 10
有什么区别？
在C语言中，const是个伪常量

const int a =10;
int *p=(int *)&a;//把a强转为int
*p=20;
printf("a=%d\n",a);
//此时打印出来的a是20，C语言中的const只是一个可读的，还是能强制修改```

在C++中const是不可修改的

const int a=10;
int *p=(int*)&a;
*p=20;
cout<<a<<endl;
//此时输出的a还是等于10；

原理：在c++中 如果定义一个常量，那么它会在内存开辟一个符号表：
key | value
a | 10
如果对一个常量取地址，编译器会临时开辟一个空间temp，让这个指针存放这个临时空间的地址
因此在

int *p=(int*)&a

取a的地址的时候并不是真正的取a的地址，而是取出编译器为a开辟的一个临时temp的地址，因此此时强转过去后修改的是temp的值，并不是a的值，所以c++中的常量是不会被修改的。

从以下代码也能看出：

const int a=10;
int b[a]={0};

这个代码在c++中是合法的，而在c语言中是会出错，因为c++中使用const就真正表示一个常量，而c语言中虽然被const修饰，但它还是一个变量

————————————————
版权声明：本文为优快云博主「无极之剑」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/yi452873250/article/details/52260261

c和c++中全局const变量
相同点：作用域相同，都是当前文件
不同点：可见范围不同
c语言中const全局变量的可见范围是整个程序，在其他文件中使用extern声明后可以使用
c+=中const全局变量的可见范围仅限于当前文件，在其他文件中不可见，所以它可以定义在头文件中，多次引入后也不会出错

1.2 从c到c++——引用

定义引用：类型名 &引用名 = 某变量名;

int n =10;
int &m = n;//称m为n的引用，m的类型为int &
const int &k = n;//称k为n的常饮用，k的类型为const int&

限制：
定义引用同时需要初始化
初始化后的引用不能再引用别的变量
不能引用常量和表达式

引用和指针的区别
1.引用在定义时初始化，此后不可修改，指针可以改变指向的数据
2.指针可以有多级，引用只有一级
3.可以有const指针如int *const p，没有const引用
4.指针本身的增减运算代表其指向的数据地址，引用本身运算等同于指向数据的运算

1.3 从C到C++——动态内存分配

动态内存分配是指在运行时编译器才能确定要分配空间的大小，该分配空间由用户释放

分配变量

T *p = new T;//如int *p = new int;T是任意类型名，p是类型T* 的指针
//动态分配出一篇大小为sizeof(T)字节的内存空间，并将该空间的起始地址赋值给P

分配变量数组

T *p = new T[N];//如int *p = new int;N为待分配数组元素个数，或整型表达式
//动态分配出一片大小为sizeof(T)*N字节的内存空间，并且将该内存空间的起始地址赋值给p

释放内存：
用new动态分配的单个内存空间，使用delete运算符释放
用new动态分配的数组内存空间，使用delete[]运算符释放

1.4 从C到C++——内联和重载

内联函数
1.什么是内联函数
用关键字inline修饰的函数就是内联函数。关键字在函数声明和定义的时候都要加上，不写系统还是会当成常规函数

2.内联函数与一般函数的区别
1）内联含函数比一般函数在前面多一个inline修饰符

2）内联函数是直接复制“镶嵌”到主函数中去的，就是将内联函数的代码直接放在内联函数的位置上，这与一般函数不同，主函数在调用一般函数的时候，是指令跳转到被调用函数的入口地址，执行完被调用函数后，指令再跳转回主函数上继续执行后面的代码；而由于内联函数是将函数的代码直接放在了函数的位置上，所以没有指令跳转，指令按顺序执行

3）一般函数的代码段只有一份，放在内存中的某个位置上，当程序调用它是，指令就跳转过来；当下一次程序调用它是，指令又跳转过来；而内联函数是程序中调用几次内联函数，内联函数的代码就会复制几份放在对应的位置上

4）内联函数一般在头文件中定义，而一般函数在头文件中声明，在cpp中定义

3.利与弊
利：避免了指令的来回跳转，加快程序执行速度

弊：代码被多次复制，增加了代码量，占用更多的内存空间

4.什么时候使用内联函数
1）函数本身内容比较少，代码比较短，函数功能相对简单

2）函数被调用得频繁，不如循环中的函数

5.什么时候不能使用内联函数
1）函数代码量多，功能复杂，体积庞大。对于这种函数，就算加上inline修饰符，系统也不一定会相应，可能还是会当成一般函数处理

2）递归函数不能使用内联函数

6.内联函数比宏更强大
看一段代码：

#include <iostream>
using namespace std;
 
#define SUM(x) x*x
 
inline int fun(int x)
{
	return x * x;
}
 
int main()
{
	int a = SUM(2 + 3);
	int b = fun(2 + 3);
 
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
 
	system("pause");
	return 0;
}

执行结果：
a = 11
b = 25

为什么通过宏执行的结果是11呢，宏比较机械和简单，只是将传入的参数直接放上去就执行，所以int a = SUM(2 + 3);就相当于int a = 2 + 3 * 2 +3;由于乘法优先级更高，所以得到a的值为11；而在内联函数中，传入的参数是5，所以得到25

为了得到正确的结果，我们应该将宏改变为：

#define SUM(x) ((x)*(x))

7.类与内联函数
1）类内定义的函数都是内联函数，不管是否有inline修饰符

2）函数声明在类内，但定义在类外的看是否有inline修饰符，如果有就是内联函数，否则不是
————————————————
版权声明：本文为优快云博主「深山里的小白羊」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/qq_33757398/article/details/81390151

重载函数：名字相同，参数类型不同，叫做函数的重载。要避免二义性

2 类和对象基础

2.1 基本概念

C语言面向过程程序设计。程序 = 数据结构 + 算法
C++面向对象程序设计，有封装、继承、多态、抽象等特点，程序 = 类 + 类 + …+ 类

类和对象
对具有共性的客观事物进行归纳，叫封装，关系称类，实例称对象

类主要由成员函数和成员变量构成，大小为成员变量大小之和，需要考虑内存对齐

类成员可访问范围为public protected private
缺省默认private

2.2 构造函数

特性
名字与类名相同
用于对对象进行初始化，为成员变量赋值
如果类没有定义，则编译器默认定义无参构造函数
在对象生成时调用，只执行一次
可有多个构造函数，如果只有一个，最好使用public

构造函数在数组中的使用

class Test{
public:
Test(int n){};//(1)
Test(int n , int m){};//(2)
Test (){};//(3)
};
Test array1[3] = {1, Test(1, 2)};//三个元素分别用(1),(2),(3)初始化
Test array2[3] = {Test(2, 3), Test(1, 2), 1};//三个元素分别用(2),(2),(1)初始化
Test* pArray[3] = {new Test(4), new Test(1, 2)};//两个元素分别用(1),(2)初始化

2.2 复制构造函数

复制构造函数形如X::X(X &)或X::X(const X&)，只有一个参数，即对同类对象的引用
什么时候调用：
1、当用一个对象去初始化同类的另一个对象时
2、类的对象作为函数参数，该函数被调用时，类复制构造函数被调用
3、类的对象作为函数返回值，该函数返回时，类复制构造函数被调用
类A定义如下

class A{
public:
    int v;
    A(const A &a){v = a.v * 2;cout<<"copy："<<v<<endl;}
    A(int num){v = num;}
    A(){}
};
void Fun1(A &a){cout<<a.v<<endl;}
A Fun2(int num){A a;a.v = num;return a;}

1、A a1(1);A a2(a1)//结果打印：copy：2
2、A a1(1);Fun(a);//1
3、cout << Fun2(3).v <<endl;//copy：6 6

A a(5);
A b;
b = a;
cout << b.v << endl;
//5

2.3 类型转换构造函数

类型转换构造函数：用于实现类型的自动转换，只有一个参数，但不是复制构造函数

定义转换构造函数的目的是实现类型的自动转换
只有一个参数，而且不是复制构造函数的构造函数，一般就可以看作是转换构造函数
当需要的时候，编译系统会自动调用转换构造函数，建立一个无名的临时对象

类A定义如下

class A{
   int v;
public:
   A(int i){v = i;}
   A(){}
};

下面哪段程序不会引发类型转换构造函数被调用
A) A a1(4)
B) A a2 = 4
C) A a3; a3 = 9;
D) A a1, a2; a1 = a2;
答：D
显式转换和隐式转换：关键字explicit
使用该关键字后，编译器只能通过显式类型转换，不能默认转换。如左边的A a3；a3 = 9会报错

类型转换构造函数
概念
定义类型转换构造函数的目的是实现类型的自动转化

只有一个参数，而且不是复制构造函数的构造函数，一般就可以看作是转换构造函数。

当需要时，编译系统会自动调用转换构造函数，建立一个无名的临时对象。
实现

class Complex {//复数类
public:
    double real, imag;
    Complex(double r, double i) {
        real = r;
        imag = i;
    }
    Complex(int r) {//类型转化构造函数
        real = r;
        imag = 0;
        cout << "int 类型转换构造函数被调用" << endl;
    }
    Complex(const Complex& c) {
        cout << "调用复制构造函数！！" << endl;
    }
    
};

对于上面的类，假设有如下实现：

int main() {
    Complex c1(2, 3);
    Complex c2 = 3;
    c1 = 9;//9被转换为一个临时complex对象
    return 0;
}

在初始化c2的时候，参数只有一个3，为int类型，所以类型转换构造函数被调用。

在执行c1 = 9的时候，由于c1已经存在，赋值号两边的类型不匹配，此时将调用类型转换构造函数将9转换为一个临时的Complex对象，在实现赋值。

所以以上的程序执行结果为：

int 类型转换构造函数被调用
int 类型转换构造函数被调用
析构函数
构造函数是在对象生成的时候起作用的，而析构函数(Destructor)正好与之相反，析构函数在对象消亡的时候起作用。

概念
名字与类名相同，在前面加上~，没有参数和返回值，一个类最多只能有一个析构函数。
析构函数在对象消亡时自动被调用，析构函数在对象消亡后做善后工作，比如释放内存空间。
如果没写析构函数，那么编译器将自动生成一个缺省的析构函数，缺省的析构函数什么也不做。
如果定义了析构函数，则编译器不再生成析构函数。
实现
有如下的Demo类：

class Demo {
public:
    char* p;
    Demo() {
        p = new char[20];
    }
    ~Demo(){
        delete[]p;
        cout << "析构函数被调用" << endl;
    }
};

在Demo类生成时，动态申请了char[20]大小的空间。在对象消亡时，将释放这一部分空间并向屏幕输出：析构函数被调用

对于上面的类，有如下的实现：

int main() {
    Demo demo;
    return 0;
}

运行可以得到以下结果：

析构函数被调用
析构函数和数组

如上面的Demo类所示，假设我们如下所示生成一个对象数组：

int main() {
    Demo array[3];
    cout << "main end!" << endl;
    return 0;
}

在对象数组array的声明周期结束的时候，三个数组对象会依次执行析构函数，输出如下内容：

main end!

析构函数被调用
析构函数被调用
析构函数被调用

析构函数和delete运算符
delete运算符会导致析构函数被调用，如下代码所示：

class Demo {
public:
    char* p;
    Demo() {
        p = new char[20];
    }
    ~Demo(){
        delete[]p;
        cout << "析构函数被调用" << endl;
    }
};
int main() {
    Demo* demo;
    demo = new Demo;
    delete demo;
    return 0;
}

当执行到delete demo;时，析构函数将会调用，产生如下输出：

析构函数被调用
当delete一个指针数组时，该数组元素也会依次调用析构函数，如下所示：

int main() {
    Demo* array;
    array = new Demo[3];
    delete[]array;
    return 0;
}

此时析构函数将会被调用3次，产生如下输出：

析构函数被调用
析构函数被调用
析构函数被调用

注意：

若new一个对象数组，那么使用delete释放时应该写[]，否则只delete一个对象，析构函数只被调用一次。

对象作为函数返回值返回后调用析构函数
当对象作为函数参数时，会导致复制构造函数的调用，同时在参数对象消亡时会导致析构函数被调用。

当对象作为函数放回值使用时，也会导致析构函数被调用

class Demo {
public:
    char* p;
    Demo() {
        p = new char[20];
    }
    ~Demo(){
        cout << "析构函数被调用" << endl;
    }
};
Demo fun(Demo demo) {
    return demo;
}

Demo obj;

int main() {
    obj = fun(obj);
    return 0;
}

在这里，我们定义了一个全局变量Demo obj;，当执行fun(obj)时，参数为一个对象，此时会导致析构函数被调用一次；

同时，fun()函数返回一个对象，当完成obj = fun(obj);的赋值后，析构函数也会被调用一次；

最后，全局变量obj消亡时析构函数在此被调用，所以以上样例产生如下输出：

析构函数被调用
析构函数被调用
析构函数被调用

作者：檀香静雪
链接：https://www.jianshu.com/p/4421f2133731
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

2.4 析构函数

  • 名字和类型相同，在前面加"~"，无参数和返回值，一个类只能有一个析构
  • 对象消亡自动调用析构
  • 没有定义则编译器自动定义缺省析构
  • 定义了析构则不生成默认缺省析构
  • 对象数组生命周期结束，每个元素的析构都会调用
  • delete和delete[]导致析构调用
    练习：假设A是一个类的名字，拥有默认构造函数，下面的程序片段会调用类A的析构函数几次
int main(){
A *p = new A[2];
A *p2 = new A;
A a;
delete []p;
}

3次
A[2]被调用两次，a调用一次

3 类和对象进阶

3.1 this指针

对象通过this来访问自己的地址，this指针是所有成员函数的隐含参数。

  • 非静态成员函数可以直接使用this来代表指向该函数作用的对象的指针
  • 友元函数没有this指针，因为友元不是类的成员，只有成员函数才有this指针
  • 静态成员函数不能使用this指针

3.2 静态成员变量、函数

静态成员：静态成员函数和静态成员变量
在声明前面加了static关键字的成员，相比于普通成员在每个对象内享有独立内存，静态成员只存一份，为所有对象共享
注意：

  • 由于被所有对象，所以不被sizeof计算在内
  • 静态成员不需要通过对象访问，访问使用类名::成员名
  • 静态成员函数本质上属于全局函数，内部不能使用this指针，不能访问非静态成员
  • 除非为静态成员常量，静态成员函数要在类外初始化

3.3 封闭类

如果类成员变量有来自其他类的对象，该类成为封闭类，对象成为成员对象
封闭类需要在构造函数中提供成员对象的初始化，可以使用初始化列表

3.4 初始化列表

构造函数的初始化列表，冒号开始，逗号分隔
两种初始化列表方式:
方式1：

class A{
public:
A():a1(10),b1(20),c1(30){};
private:
int a1;
int b1;
int c1;
}

方式2：

class A{
public:
A(int a, int b, int c):a1(a), b1(b), c1(c){};
private:
int a1;
int b1;
int c1;
}
int main(){
A n(10, 20, 30);
}

初始化列表能只能初始化一次，多次初始化会报错

编译器也允许构造函数赋初值和初始化列表初始化混用


class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 4, int day = 19)
		:_year(year)  //两者混用
		,_month(month)
	{
		_day = day;
	}
 
private:
	int _year;
	int _month;
	int _day;
};
————————————————
版权声明：本文为优快云博主「玲娜贝儿~」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/gx714433461/article/details/124285721

使用要求
1、封闭类，其成员对象没有默认构造函数的类
2、const成员或引用类型的成员

初始化列表的成员初始化顺序按照声明的顺序初始化，不按照出现在初始化列表中的顺序

3.4 常量成员函数和友元函数

友元分为友元函数和友元类
友元函数：一个类的友元函数可以访问该类的私有成员
友元类：A是B的友元类，A的成员函数可以访问B的私有成员

友元关系不能传递

常量成员函数：声明和定义后面加const

xiehanhust
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值