c++析构函数
C++_构造函数与析构函数
C++_构造函数与析构函数构造函数与析构函数1 构造函数1.1 构造函数具有⼀些特殊的性质1.2 定义构造函数的⼀般形式1.3 利⽤构造函数创建对象2 成员初始化表3 缺省参数的构造函数4 重载构造函数5 拷贝构造函数5.1 ⾃定义拷贝构造函数5.2 缺省的拷贝构造函数5.3 调⽤拷贝构造函数的三种情况5.4 浅拷贝和深拷贝6 析构函数7 调⽤构造函数和析构函数的顺序8 对象的⽣存期构造函数和析构函数都是类的成员函数,但它们都是特殊的成员函数,执⾏特殊的功能,不⽤调⽤便⾃动执⾏,⽽且这些函数的名字与类的名字有关。
C++语⾔中有⼀些成员函数性质是特殊的，这些成员函数负责对象的建⽴、删除。
这些函数的特殊性在于可以由编译器⾃动地隐含调⽤，其中⼀些函数调⽤格式采⽤运算符函数重载的语法。
C++引进⼀个⾃动完成对象初始化过程的机制，这就是类的构造函数。
对象的初始化1. 数据成员是不能在声明类时初始化2. 类型对象的初始化⽅法：1. 调⽤对外接⼝（public成员函数）实现：声明类→定义对象→调⽤接⼝给成员赋值2. 应⽤构造函数（constructor）实现：声明类→定义对象→同时给成员赋值1. 构造函数构造函数是⼀种特殊的成员函数,它主要⽤于为对象分配空间,进⾏初始化。
1.1 构造函数具有⼀些特殊的性质:(1) 构造函数的名字必须与类名相同。
(2) 构造函数可以有任意类型的参数,但不能指定返回类型。
它有隐含的返回值,该值由系统内部使⽤。
(3) 构造函数是特殊的成员函数,函数体可写在类体内,也可写在类体外。
(4) 构造函数可以重载,即⼀个类中可以定义多个参数个数或参数类型不同的构造函数。
构造函数是不能继承(5) 构造函数被声明为公有函数,但它不能像其他成员函数那样被显式地调⽤,它是在定义对象的同时被调⽤的。
(6) 在声明类时如果没有定义类的构造函数，编译系统就会在编译时⾃动⽣成⼀个默认形式的构造函数，(7) 默认构造函数是构造对象时不提供参数的构造函数。
C++基抽象类的构造析构（纯）虚函数
C++基抽象类的构造析构（纯）虚函数⼀、析构函数可定义为⼀、析构函数可定义为纯虚函数纯虚函数，但也必须给出函数定义，但也必须给出函数定义 Effective C++ 条歀07: 为多态基类声明virtual 析构函数（Declare destructors virtual in polymorphic base classes ） 在某些类⾥声明纯虚析构函数很⽅便。
纯虚函数将产⽣抽象类——不能实例化的类（即不能创建此类型的对象）。
有些时候，你想使⼀个类成为抽象类，但刚好⼜没有任何纯虚函数。
怎么办？因为抽象类是准备被⽤做基类的，基类必须要有⼀个虚析构函数，纯虚函数会产⽣抽象类，所以⽅法很简单：在想要成为抽象类的类⾥声明⼀个纯虚析构函数。
1 //这⾥是⼀个例⼦：2 class awov {3 public :4 virtual ~awov() = 0; // 声明⼀个纯虚析构函数5 }; 这个类有⼀个纯虚函数，所以它是抽象的，⽽且它有⼀个虚析构函数，所以不会产⽣析构函数问题。
但这⾥还有⼀件事：必须提供纯虚析构函数的定义： awov::~awov() { ... } // 纯虚析构函数的定义 这个定义是必需的，因为虚析构函数⼯作的⽅式是：最底层的派⽣类的析构函数最先被调⽤，然后各个基类的析构函数被调⽤。
这就是说，即使是抽象类，编译器也要产⽣对~awov 的调⽤，所以要保证为它提供函数体。
如果不这么做，链接器就会检测出来，最后还是得回去把它添上。
⼆、？ 关于C++为什么不⽀持虚拟构造函数，Bjarne 很早以前就在C++Style and Technique FAQ ⾥⾯做过回答 Avirtual call is a mechanism to get work done given partialinformation. In particular, "virtual" allows us to call afunction knowing only an interfaces and not the exact type of theobject. To create an object you need complete information.Inparticular, you need to know the exact type of what you want tocreate. Consequently, a "call to a constructor" cannot bevirtual. 含义⼤概是这样的：虚函数调⽤是在部分信息下完成⼯作的机制，允许我们只知道接⼝⽽不知道对象的确切类型。
C++在单继承、多继承、虚继承时，构造函数、复制构造函数、赋值操作符、析构函数的执行顺序和执行内容
C++在单继承、多继承、虚继承时，构造函数、复制构造函数、赋值操作符、析构函数的执⾏顺序和执⾏内容⼀、本⽂⽬的与说明1. 本⽂⽬的：理清在各种继承时，构造函数、复制构造函数、赋值操作符、析构函数的执⾏顺序和执⾏内容。
2. 说明：虽然复制构造函数属于构造函数的⼀种，有共同的地⽅，但是也具有⼀定的特殊性，所以在总结它的性质时将它单独列出来了。
3. 单继承、多继承、虚继承，既然都属于继承，那么虽然有⼀定的区别，但还是相同点⽐较多。
如果放在⼀块讲，但为了将内容制作成递进的，就分开了，对相同点进⾏重复，（⼤量的复制粘贴哈），但在不同点进⾏了标注。
注意：三块内容是逐步递进的如果你懂虚函数，那么单继承和多继承那块你就可以不看；如果你懂多继承，那单继承你就不要看了，⾄于虚继承就等你懂虚继承再回来看吧；如果你只懂单继承，那你就只看单继承就好。
⼆、基本知识1. 对于⼀个空类，例如：class EmptyClass{};虽然你没有声明任何函数，但是编译器会⾃动为你提供上⾯这四个⽅法。
class EmptyClass {public:EmptyClass(); // 默认构造函数EmptyClass(const EmptyClass &rhs); // 复制构造函数~EmptyClass(); // 析构函数EmptyClass& operator=(const EmptyClass &rhs); // 赋值运算符}对于这四个⽅法的任何⼀个，你的类如果没有声明，那么编译器就会⾃动为你对应的提供⼀个默认的（注意合成默认构造函数是⽤于没有编写构造函数编译器才会合成默认构造函数，其中复制构造函数也是构造函数）。
（在《C++ primer》中，这个编译器⾃动提供的版本叫做“合成的***”，例如合成的复制构造函数）当然如果你显式声明了，编译器就不会再提供相应的⽅法。
2. 合成的默认构造函数执⾏内容：如果有⽗类，就先调⽤⽗类的默认构造函数。
聊城大学计算机学院面向对象的程序设计(c++)练习题(第三周)(构造函数和析构函数)
聊城大学计算机学院面向对象的程序设计第三次作业一、单选题（本大题共17小题，每题3分，共51分）：1、在下列函数原型中，可以作为类AA构造函数的是（）。
A void AA(int)；B int AA( );C AA(int) const；D AA(int);2、下列选项中，哪一项功能是对对象进行初始化（）。
A 析构函数B 数据成员C 构造函数D 静态成员函数3、假定A为类名，执行A x;语句时将自动调用该类的（）。
A 有参构造函数B 无参构造函数C 拷贝构造函数D 赋值构造函数4、下列关于构造函数的说法，错误的是（）。
A 系统可以提供默认的构造函数B 构造函数可以有参数，所以可以有返回值C 构造函数可以重载D 构造函数可以设置默认参数5、有如下类定义：class Point{int x, y;public:Point__________:x_(0), y_(0){}Point(int x, int y = 0):x_(x), y_(y){}};若执行语句：Point a(2), b[3], *c[4];则Point类的构造函数被调用的次数是（）。
A 2次B 3次C 4次D 5次6、在下面的类定义中class sample{public:sample(int val); //①~sample( ); //②private:int a=2.5; //③public:sample( ); //④};其中错误的语句是（）。
A ①B ②C ③D ④7、假定一个类的构造函数为A(int i = 4, int j = 0) { a = i; b = j;}则执行A x(1)语句后，x.a和x.b的值分别为（）。
A 1和0B 1和4C 4和0D 4和18、下列关于构造函数的描述中，错误的是（）。
A 构造函数可以设置默认参数B 构造函数在定义类对象时自动执行C 构造函数可以是内联函数D 构造函数不可重载9、下列选项中，哪一项不是构造函数的特征（）。
C list函数详解
一、构造、析构函数、=运算符1、功能：声明list容器。
4种方式list<int> first;// empty list of intslist<int> second (4,100);// four ints with value 100。
4个100list<int> third (),());// iterating through secondlist<int> fourth (third);// a copy of third2、功能：注销list。
~list ( );3、原型：list1 = list2;功能：将list2赋值给list1，包括list的所有元素以及list2的size返回值：this指针二、返回迭代器类的函数begin、end、rbegin、rend举例：Begin指向第一个元素，黄色箭头。
end是最后一个元素的后一个位置，黑色箭头。
Begin和end一般一起使用，按正序输出list。
rbegin指逆序的第一个元素，即最后一个元素，蓝色箭头。
rend指逆序的最后一个元素的前一个位置，即第一个元素的前一个位置，红色箭头。
Rbegin和rend一般一起使用，用于逆序输出list。
三、list的容量相关的函数1、empty原型：bool empty ( ) const;功能：判断lsit是否为空，即size是否为0返回值：size为0，返回true，否则，返回false2、size原型：size_type size() const;功能：返回lsit中元素的个数返回值：size_type3、Max_size原型：size_type max_size () const;功能：返回lsit的最大容量返回值：4、resize原型：void resize ( size_type sz, T c = T())；功能：重新分配lsit的大小。
C++复习题及答案
A int a[10]B int a[2,5]
C int a[]D int *a[10]
6、如果变量x,y已经正确定义，下列语句哪一项不能正确将x,y的值进行交换（D）。
Ax=x+y,y=x-y,x=x-y
Bt=x,x=y;y=t
Ct=y,y=x,x=t
24、在定义int a[5][4];之后，对a的引用正确的是（C）。
A a[2][4]B a[5][0]
C a[0][0]D a[0,0]
25、在一个类的定义中，包含对什么成员的定义（C）。
A数据B函数
C数据和函数D数据或函数
26、在计算机上可以直接运行的程序是（D）。
AC++源程序B高级语言程序
C汇编语言程序D 机器语言程序
A 大小写字母B 下划线
C 连接符D 数字字符
17、若类X是类Y的友元类，则下列哪种访问关系是正确的（B）。
A 类X的成员不能访问类Y的私有成员
B 类X的成员可以访问类Y的私有成员
C 类Y的成员可以访问类X的私有成员
D 只有类Y的公共成员才能访问类X的私有成员
18、如果编程者没有显式定义构造函数（包括复制构造函数），C++编译器就（D）。
20、请写出与数学表达式4/3πR3相对应的C++表达式4.0/3*3.14*R*R*R。
21、在C++中，函数参数的两种传递方式分别是值传递和地址传递。
22、一个类和对象的关系，正如基本数据类型与该类型的变量一样，如int x;。
23、在一个类中定义常数据成员用关键字const，定义静态数据成员用关键字static。
析构函数的特征
析构函数的特征包括
A．一个类中只能定义一个析构函数
B．析构函数与类名没有关系
C．析构函数的定义只能在类体内部
D．析构函数可以有一个或多个参数
正确答案
A
答案解析
[解析] 析构函数不能有参数，是惟一的，没有返回类型，其主要工作就是完成对象销毁前的资源回收等工作。
补充资料
析构函数与构造函数相反。
当对象结束其生命周期（例如对象所在的功能）时，系统会自动执行析构函数。
析构函数通常用于“清理后果”（例如，在创建对象时，使用new来打开内存空间，而delete 将自动调用析构函数以释放内存）。
功能介绍
与构造函数相比，当对象结束其生命周期时（例如，调用其函数时），系统将自动执行析构函数。
以C ++语言为例：析构函数的名称应与类名相同，但应在函数名称之前添加一些反转字符〜，例如〜study（），以将其与构造函数区分开。
它不能接受任何参数，并且没有返回值（包括void类型）。
只能有一个析构函数。
它不能过载。
如
果用户未编写析构函数，则编译器将自动生成默认的析构函数（即使定义了自定义析构函数，编译器也会始终为我们合成一个析构函数，如果定义了自定义析构函数，则编译器将调用自定义析构函数析构函数，然后调用综合析构函数），它将不会执行任何操作。
许多简单的类不使用显式析构函数。
C++期末试题讲解
选择题：1．若有以下说明，在类外使用对象 objX 成员的正确语句是(C )。
class X{ int a;void fun1();public:void fun2();};X objX ;(a) objX.a=0;(b) objX.fun1();(c) objX.fun2();(d) X::fun1();2．若有以下说明，对 n 的正确访问语句是( B)。
class Y{ //…… ;public:static int n;};int Y::n;Y objY;(a) n=1;(b) Y::n=1;(c) objY::n=1;(d) Y->n3．若有以下类Z说明，函数fStatic中访问数据a错误的是( C )。
class Z{ static int a;public:static void fStatic();};int Z::a = 0 ;Z objZ ;(a) void Z::fStatic(){ objZ.a = 1; }(b) void Z::fStatic(){ a = 1; }(c) void Z::fStatic(){ this->a = 0 ; }(d) void Z::fStatic(){ Z::a = 0 ; }4．若有以下类 W 说明，函数 fConst 的正确定义是( A )。
class W{ int a;public:void fConst(int) const ;};(a) void W::fConst(int k)const { k=a; }(b) void W::fConst(int k)const { k=a++; }(c) void W::fConst(int k)const { cin>>a; }(d) void W::fConst(int k)const { a=k; }5．若有以下类 T 说明，函数 fFriend 的错误定义是( C )。
C++基础面真题
1.const符号常量：〔1〕、const char Xp〔2〕、char const Xp〔3〕、char X const p如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量。
如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。
2.析构函数和虚函数的用法和作用？析构函数的作用是当对象生命期结束时释放对象所占用的资源。
析构函数用法：析构函数是特别的类成员函数它的名字和类名相同，没有返回值，没有参数不能随意调用也没有重载。
只是在类对象生命期结束时有系统自动调用。
虚函数用在继承中，当在派生类中需要重新定义基类的函数时需要在基类中将该函数声明为虚函数，作用为使程序支持动态联遍。
3.堆和栈的区别栈〔stack〕：由编译器自动分配释放，存放函数的参数值，局部变量的值等。
其操作方法类似于数据结构中的栈。
堆：一般由程序员分配释放，假设不释放，程序结束时可能由OS回收。
注意它与数据结构中的堆是两回事，分成分法类似。
4.头文件的作用是什么？1.通过头文件来调用库功能。
在很多场合，源代码不便〔或不准〕向用户公布，只要向用户提供头文件和二进制的库即可。
用户只需要按照头文件中的接口声明来调用库功能，而不必关心接口怎么完成的。
编译器会从库中提取出相应的代码。
2.头文件能加强类型平安检查。
如果某个接口被完成或被使用时，其方法与头文件中的声明不一致，编译器就会指出错误，这一简单的规则能大大减轻程序员调试、改错的负担。
5.内存的分成分法有几种？1.从静态存储地域分配。
内存在程序编译的时候已经分配好，这块内存在程序的整个运行期间都存在。
如全局变量。
2.在栈上创立。
在执行函数时，函数内局部变量的存储单元都可以在栈上创立，函数执行结束时这些存储单元自动被释放。
栈内存分配运算内置于处理器的指令集中，效率高，但是分配的内存容量有限。
3.从堆上分配，亦称动态内存分配。
程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。
有10个指针的数组,该指针指向函数
有10个指针的数组,该指针指向函数函数指针是C语言中的一个重要概念，它可以指向程序中的函数，从而使得我们可以在程序运行过程中动态地调用不同的函数。
在本文中，我们将介绍10个不同类型的函数指针，并分别讨论它们的用途和特点。
1. 指针参数函数指针参数函数是一种常见的函数类型，它接受一个指针作为参数，并对指针所指向的数据进行操作。
例如，我们可以定义一个指针参数函数来交换两个变量的值：```cvoid swap(int* a, int* b) {int temp = *a;*a = *b;*b = temp;}```2. 返回指针的函数返回指针的函数是指该函数返回一个指针作为结果。
这种函数通常用于动态分配内存或返回数组的地址。
例如，我们可以定义一个返回动态分配内存的函数：```cint* createIntArray(int size) {int* arr = (int*)malloc(size * sizeof(int));return arr;}```3. 函数指针数组函数指针数组是一个数组，每个元素都是一个函数指针。
我们可以通过函数指针数组来实现函数的动态调用。
例如，我们可以定义一个函数指针数组，其中包含不同的排序算法函数：```cvoid bubbleSort(int* arr, int size) { ... }void selectionSort(int* arr, int size) { ... }void insertionSort(int* arr, int size) { ... }void (*sortAlgorithms[3])(int*, int) = { bubbleSort, selectionSort, insertionSort };```4. 函数指针作为回调函数函数指针作为回调函数是指将一个函数指针作为参数传递给另一个函数，使得后者可以在适当的时候调用前者。
这种机制常用于事件驱动编程中。
c课后习题解答
第6章;类和对象(一)练习题6判断题×1．使用class定义的类，其默认的访问权限是公有的，使用struct定义的类，其默认的访问权限是私有的。
×2．类中的成员函数都是公有的，数据成员都是私有的。
×3．定义在类体内的成员函数是内联函数，定义在类体外的成员函数不能是内联函数。
√4．类定义后，它的成员个数及名称就不会再被改变了。
×5．定义或说明对象时，系统会自动调用构造函数为创建的对象初始化。
如果类中没有定义任何构造函数时，就无法给定义的对象初始化。
√6．定义一个对象时，系统只为该对象的数据成员开辟内存空间，而成员函数是同类对象共享的。
√7．对象成员的表示方法与结构变量成员的表示方法相同。
√8．创建对象时系统自动调用相应的构造函数为对象初始化，没有相应的构造函数时，系统会自动生成。
√9．构造函数是一个其名与类名相同的特殊的成员函数。
×10．析构函数是一个函数体为空的成员函数。
√11．构造函数和析构函数都是系统自动调用的成员函数。
×12．构造函数和析构函数都可以重载。
√13．成员函数与一般函数一样可以重载、内联和设置参数的默认值。
×14．静态成员是指静态对象的成员。
×15．静态数据成员必须在构造函数的成员初始化列表中进行初始化。
√16．静态成员都可以使用类名加作用域运算符的方法来引用。
×17．静态成员函数中引用静态数据成员和非静态数据成员的方式是相同的。
√18．常成员指的是类体内使用const关键字说明的常数据成员和常成员函数。
×19．常数据成员在常成员函数中的值是不允许改变的，而在非常成员函数中是允许改变的。
√20．常对象需要引用常成员函数，而不能引用非常成员函数。
×21．常对象的数据成员都是常数据成员。
√22．友元函数是说明在类体内的非成员函数，它可以访问类中的所有成员。
×23．可以把一个一般函数说明为某类的友元函数，也可以将某类的成员函数说明为另类的友元函数。
类、构造函数、析构函数
类：1、在类体中不允许对所定义的数据成员进行初始化。
2、类的成员函数描述类所表达的问题的行为。
类中所有的成员函数都必须在类体内进行说明。
但成员函数的定义既可以在类体内给出，也可以在类体外给出。
第一种方式是将成员函数直接定义在类的内部。
第二种方式是在类声明中给出对成员函数的说明，而在类外部对成员函数进行定义(但成员函数仍然在类范围内)。
这种在类外部定义的成员函数的一般格式是：＜返回类型＞＜类名＞：：＜成员函数名＞(＜参数表＞)｛＜函数体＞｝在类体外定义成员函数时，要注意必须在成员函数名前加上类名和作用域运算符(：：)。
作用域运算符用来标识某个成员属于某个类。
作用域运算符的使用格式如下：＜类名＞：：＜成员函数名＞(＜参数表＞)或＜类名＞：：＜数据成员名＞成员函数的两种定义方式之间是有差别的。
如果一个成员函数的声明和定义都在类体内，那么这个成员函数就是内联函数。
如果一个成员函数的声明在类体内，而定义在类体外，这时对该成员函数的调用是按一般函数进行的。
如果要将定义在类体外的成员函数也作为内联函数处理，就必须在成员函数的定义前加上关键字“inline”，以此显式地说明该成员函数也是一个内联函数。
成员函数除了可以定义为内联函数以外，也可以进行重载，可以对其参数设置默认值。
6.3 构造函数和析构函数1、构造函数和析构函数的定义。
构造函数的作用是在对象被创建时利用特定的值构造对象，将对象初始化为一种特定的状态，使该对象具有区别于其他对象的特征。
构造函数在对象被创建的时候由系统自动调用。
构造函数也是类的成员函数，但它是一种特殊的成员函数，它除了具有一般成员函数的特性之外，还具有一些特殊的性质：(1)构造函数的名字必须与类名相同；(2)构造函数不指定返回类型，它隐含有返回值，由系统内部使用；(3)构造函数可以有一个或多个参数，因此构造函数可以重载；(4)在创建对象时，系统会自动调用构造函数。
2、缺省构造函数和缺省析构函数缺省构造函数就是调用时不必提供参数的构造函数。
c语言构造函数和析构函数
c语言构造函数和析构函数C语言构造函数和析构函数构造函数和析构函数是面向对象编程（OOP）中的重要概念。
它们用于在对象的创建和销毁过程中执行特定的操作。
然而，在C语言中并没有内置的构造函数和析构函数的概念，因为C语言不直接支持面向对象编程。
然而，我们可以通过一些技巧来模拟构造函数和析构函数的行为。
本文将逐步解释如何实现这些概念，并探讨构造函数和析构函数在C语言中的应用。
第一步：模拟构造函数构造函数在对象创建时被自动调用，用于初始化对象的成员变量。
在C语言中，我们可以通过在函数中手动分配内存并初始化对象来模拟构造函数的行为。
首先，我们需要定义一个结构体来表示我们要创建的对象。
结构体可以包含多个成员变量，每个成员变量代表对象的一个属性。
例如，我们可以创建一个学生对象，其中包含姓名和年龄两个成员变量。
ctypedef struct {char name[20];int age;} Student;接下来，我们可以编写一个创建学生对象的函数，该函数将分配内存并初始化学生对象的成员变量。
cStudent* createStudent(char* name, int age) {Student* student = (Student*)malloc(sizeof(Student));strcpy(student->name, name);student->age = age;return student;}在上述代码中，我们使用malloc函数分配了一块内存，大小足够容纳一个Student结构体。
然后，我们使用strcpy函数将传入的姓名参数复制到student对象的name成员变量中，使用赋值运算符初始化age成员变量。
最后，我们将指向新创建的学生对象的指针返回。
现在，我们可以调用createStudent函数来创建一个学生对象，并访问其成员变量。
cint main() {Student* student = createStudent("Tom", 20);printf("Name: s, Age: d\n", student->name,student->age);free(student);return 0;}在上述代码中，我们首先调用createStudent函数来创建一个学生对象，并将返回的指针赋给student指针。
C语言实验报告
C语⾔实验报告上机要求：禁⽌玩游戏、看视频及从事与课程⽆关的活动。
实验内容按照指导书内容填写，可以把⾃⼰上机编写的程序、遇到的问题、解决办法写上（得到⾼分的条件）。
在有输⼊输出的程序部分，应该写上输⼊输出的结果，以表⽰程序能正确⼯作。
实验⼀编程环境的使⽤⼀、⽬的和要求1.了解编程环境的使⽤。
2.学会处理简单的错误，观察运⾏结果。
3.掌握基本的输⼊输出。
⼆、实验原理VisualC++6.0是⼀个集成的开发环境，包括编辑、编译连接和调试。
编写程序的主要过程是：建⽴⼯作区、建⽴⼯程、添加源⽂件、输⼊程序、运⾏程序、改正出现的错误直到有正确的输出结果。
三、实验内容及步骤1.编程环境的使⽤。
(1)打开VisualC++6.0开发环境。
(2)单击“⽂件-〉新建”菜单命令，显⽰出“新建”对话框（如图1-3）。
在新建对话框单击“⼯程”标签，选中Win32 Console Application项，然后在⼯程框中键⼊控制台应⽤程序项⽬名称，并且选中空⼯程。
(3)添加C++源⽂件，输⼊⽂件名。
(4)打开编辑窗⼝，输⼊程序，保存。
(5)编译运⾏程序，找到其错误位置，改正错误。
2.编写如下程序，从键盘读⼊两个整数，计算它们的和差积商，将结果输出在屏幕上。
3.编写如下程序，从键盘读⼊两个字符，并输出在屏幕上。
四、思考问题1.如何使⽤不同的数据类型。
2.如何处理输⼊输出。
3.如何查找程序中的错误？实验⼆选择结构⼀、⽬的和要求1. 掌握if ...else 及其嵌套的⽤法。
2. 掌握switch 的⽤法。
⼆、实验原理if 语句是专门⽤来实现选择结构的语句，是根据⼀个条件满⾜与否来决定是否执⾏某条语句或从两个语句中选择⼀个语句执⾏。
if-else 语句的⼀般格式为：if (表达式1) 语句1else if （表达式2）语句2……else if （表达式n ）语句nelse 语句n+1当程序中有多个条件判断时，若使⽤if 语句可能使嵌套太多，降低了程序的可读性，switch 语句能很好的解决这个问题。
c语言申请和释放内存的语句
在C语言中，内存的申请和释放需要使用动态内存分配函数和析构函数。
1. 内存申请：使用动态内存分配函数malloc()或calloc()可以申请一定大小的内存空间。
malloc()函数用于申请单块内存，而calloc()函数用于申请多块内存。
malloc()函数的语法如下：void* malloc(size_t size);其中，size表示需要申请的内存空间大小，返回值为指向申请到的内存空间的指针。
calloc()函数的语法如下：void* calloc(size_t num, size_t size);其中，num表示需要申请的内存空间数量，size表示每个内存空间的大小，返回值为指向申请到的内存空间的指针。
2. 内存释放：使用free()函数可以释放动态申请的内存空间。
free()函数的语法如下：void free(void* ptr);其中，ptr表示需要释放的内存空间指针。
在释放内存之前，需要先检查申请到的内存空间是否已经被释放，否则会导致内存泄漏。
3. 使用智能指针在C++中，可以使用智能指针来管理动态分配的内存空间。
智能指针可以自动释放内存空间，避免了内存泄漏的问题。
智能指针的语法如下：#include <memory>std::unique_ptr<T> make_unique(T* ptr);std::shared_ptr<T> make_shared(T* ptr);std::weak_ptr<T> make_weak(T* ptr);其中，T表示需要管理的对象类型。
make_unique()和make_shared()函数分别用于创建unique_ptr和shared_ptr类型的智能指针，make_weak()函数用于创建weak_ptr类型的智能指针。
使用智能指针的优点在于，可以避免手动管理内存空间的问题，同时也可以避免内存泄漏的问题。
C语言中的malloc和C++中new的区别
n ew和malloc的区别1、new 是c++中的操作符，malloc是c 中的一个函数2、new 不止是分配内存，而且会调用类的构造函数，同理delete会调用类的析构函数，而malloc则只分配内存，不会进行初始化类成员的工作，同样free也不会调用析构函数3、内存泄漏对于malloc或者new都可以检查出来的，区别在于new可以指明是那个文件的那一行，而malloc没有这些信息。
4、new 和malloc效率比较new 有三个字母, malloc有六个字母new可以认为是malloc加构造函数的执行。
new出来的指针是直接带类型信息的。
而malloc返回的都是void指针。
一：new delete 是运算符，malloc,free是函数malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。
它们都可用于申请动态内存和释放内存。
对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。
对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。
由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。
因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。
注意new/delete不是库函数。
我们先看一看malloc/free和new/delete如何实现对象的动态内存管理，见示例。
class Obj{public :Obj(void){ cout << “Initialization” << endl; }~Obj(void){ cou t << “Destroy” << endl; }void Initialize(void){ cout << “Initialization” << endl; }void Destroy(void){ cout << “Destroy” << endl; }};void UseMallocFree(void){Obj *a = (obj *)malloc(sizeof(obj)); // 申请动态内存a->Initialize(); // 初始化//…a->Destroy(); // 清除工作free(a); // 释放内存}void UseNewDelete(void){Obj *a = new Obj; // 申请动态内存并且初始化//…delete a; // 清除并且释放内存}示例用malloc/free和new/delete如何实现对象的动态内存管理类Obj的函数Initialize模拟了构造函数的功能，函数Destroy模拟了析构函数的功能。
析构函数定义
析构函数定义析构函数是C++类成员函数的一种，它的作用是在对象被销毁时释放对象所占用的资源。
析构函数是一种特殊的函数，它的名称是由类名称前加上字符"~"所构成的。
析构函数没有参数，也没有返回值，它的声明形式为：~ClassName()。
```class ClassName {public:// 构造函数ClassName();// 析构函数~ClassName();};```1.2 析构函数的作用在C++语言中，创建一个对象时，系统会为这个对象分配所需要的内存空间，并在对象的生命周期结束时释放这些空间。
析构函数可以用来完成释放内存等资源的工作。
析构函数调用的时机与构造函数恰好相反，在对象生命周期结束时自动调用，以便完成清理工作。
析构函数是自动地、不可显式地调用的。
使用析构函数的目的是确保对象在生命周期结束时，能够释放任何由其占用的内存资源，避免内存泄漏等问题的出现。
如果一个对象所占用的内存资源没有得到释放，那么就会造成内存泄漏，导致程序崩溃或内存耗尽等问题。
2.1 局部对象的销毁当一个对象在函数内部定义时，它就是一个局部对象，它的生命周期与所在的函数相同。
当函数执行结束时，局部对象就会被销毁，此时就会自动调用析构函数以释放所占用的资源。
```#include <iostream>#include <string>using namespace std;class Person {public:// 构造函数Person(string name) { m_name = name; }// 析构函数~Person() { cout << "Person " << m_name << " is destroyed." << endl; }private:string m_name;};输出：在上面的程序中，创建一个名为Tom的Person对象。
ctrl c 析构函数
ctrl c 析构函数Ctrl+C是计算机上一个常见的快捷键，用于复制选定的文本或其他对象。
在编程中，Ctrl+C还有另外一个含义，即析构函数。
本文将以Ctrl+C析构函数为主题，详细介绍析构函数的定义、作用、使用方法以及一些注意事项。
我们来了解一下什么是析构函数。
在面向对象的编程中，类是一种自定义的数据类型，它可以包含属性和方法。
当我们创建一个类的对象时，系统会自动调用构造函数来初始化对象。
而当对象不再被使用时，系统则会调用析构函数来清理对象占用的资源。
简单来说，析构函数的作用就是在对象销毁时执行一些清理工作。
那么，如何定义析构函数呢？在C++中，析构函数的命名规则与构造函数相同，以类名为函数名，前面加上一个波浪线(~)作为前缀。
例如，如果一个类名为Person，那么它的析构函数的定义应该是~Person()。
需要注意的是，析构函数不需要任何参数，也不需要返回值。
接下来，让我们了解一下析构函数的使用方法。
当我们使用new关键字创建一个对象时，系统会自动调用构造函数来初始化对象，并分配内存空间。
而当我们使用delete关键字销毁对象时，系统则会自动调用析构函数来清理对象占用的资源，并释放内存空间。
这个过程是自动进行的，无需我们手动调用析构函数。
在某些情况下，我们可能需要手动调用析构函数。
例如，当一个对象是在栈上创建的而非堆上，那么当它离开作用域时，系统会自动调用析构函数来销毁对象。
但是，如果我们在对象离开作用域之前就想手动销毁对象，可以使用delete关键字来显式调用析构函数。
需要注意的是，手动调用析构函数后，对象的内存空间不会被释放，只有使用delete关键字才能释放内存空间。
除了上述用法，析构函数还有一些注意事项需要我们注意。
首先，析构函数不能被继承，它只属于基类中的对象。
其次，析构函数应该是虚函数，以确保在删除一个指向派生类对象的基类指针时，能正确调用派生类的析构函数。
最后，析构函数中应该释放对象占用的资源，例如关闭文件、释放动态分配的内存等。
析构函数定义
析构函数定义析构函数是在对象被销毁时自动调用的特殊成员函数，用于释放对象所占用的资源。
在C++中，析构函数的命名规则是在类名前加上一个波浪号“~”，例如：“~ClassName”。
析构函数的定义和声明与其他成员函数类似，通常在类的定义中声明，在类的外部定义。
在类的定义中，析构函数的声明应该放在公有成员函数的后面，格式为“~ClassName();”。
在类的外部定义析构函数时，也需要加上类名和波浪号，格式为“ClassName::~ClassName(){ //函数体}”。
析构函数没有参数，也没有返回值，其唯一的作用就是在对象生命周期结束时进行清理工作。
在析构函数中，通常会释放动态分配的内存、关闭打开的文件、释放资源等。
例如，如果在构造函数中使用了new关键字动态分配了内存，那么在析构函数中需要使用delete关键字释放这块内存，以避免内存泄漏。
在使用析构函数时，需要注意以下几点：首先，析构函数的调用是自动的，不需要手动调用。
当对象的作用域结束时，或delete运算符被用来释放动态分配的对象时，析构函数会被自动调用。
其次，如果一个类没有定义析构函数，编译器会为其生成一个默认的析构函数，这个默认的析构函数不会执行任何操作。
但是，如果类中有动态分配的资源，且没有在析构函数中释放，会导致内存泄漏的问题。
另外，如果一个类是继承关系的基类，那么析构函数应该被声明为虚函数，以确保在派生类的对象被删除时，会调用到正确的析构函数，避免资源的泄漏。
总的来说，析构函数的定义是C++中重要的概念之一，能够帮助我们在对象生命周期结束时，自动释放资源，避免内存泄漏等问题的发生。
合理的使用析构函数，可以提高程序的健壮性，减少资源的浪费，是每一个C++程序员都应该掌握的知识点。