c++期末复习

繁芜~

已于 2022-06-03 13:09:02 修改

阅读量698

点赞数 4

文章标签： c++

于 2022-06-03 12:51:57 首次发布

本文链接：https://blog.csdn.net/weixin_60303223/article/details/125111815

版权

c++期末复习

1.c++与c的关系（面向对象、面向过程）

c语言面向过程类与对象，c++语言面向对象以c语言为基础拓展（有类与对象

2. 引用的定义和使用

int a;
int &a_name=a;//表示给a起一个别名，将a的地址分享给a_name，所以引用和被引用的变量占有相同的存储空间,改变a_name值就能改变a的值，指针的封装也可以说是。

3.调用重载函数的根据

重载就是对具有相同函数名的函数进行调用，调用时系统根据函数的参数类型和参数个数进行同名函数的调用
注意：返回类型不同不能引起重载，重载函数和带默认参数的函数一起调用时会引起二义性

    int abs(int n)
    int abs(long n)
    int abs(int n,long n)
        
    int abs(int x,int y,int z=0)
        int abs(int n,int )
        abs(3,500)//出错，二义性

4.调用对象数组，构造函数被调用几次？

定义了多大的对象数组，就调用多少次构造函数

5.对象成员调用构造函数的顺序

1.先执行基类构造函数

2.若定义了对象成员，再执行对象成员的构造函数，就先调用该对象成员的构造函数，对象成员调用顺序按照函数声明顺序来

3.最后执行派生类的构造函数

class a
{
    public:
    a()
    {}
};
class b:public a
{
    public:
    b():a()
    {}
};
class c:public b
{
    private:
        b b1;
    public:
    c():b(),b1(10.58)
    {}
};
void main()
{
    c c1(10,50);//先调用派生类b构造函数，类b调用基类a构造函数，接着对象b1调用派生类b构造函数，类b调用a类构造函数，最后调用c1的构造函数。
}

6.友元函数是不是成员函数？

答：友元函数不是类的函数，但是可以将友元函数设置成类的成员函数。友元函数可以访问类的所有成员

注意：类虽然可以访问所有成员，但是不能直接访问（i=1），只能通过对象、对象指针、引用进行访问

friend 数据类型 函数名（）
{}
friend int ABS()
{}

友元类：可以将一个类定义为另一个类的友元，这个类就是友元类，友元类的所有成员是另一个类的友元函数。

7.Delete删除对象，析构函数和释放内存顺序？

答：析构函数调用顺序

与构造函数相反

先执行派生类的析构函数->再执行对象成员的析构函数->最后执行基类的析构函数

拓展：delete只能释放指针的首地址，不能释放指针指向的首地址已经改变的情况。

int *p new int[10];
    *p++;
delete p;//错误，指针已经没有指向首地址


int *p new int[10];
delete p;//正确

8.虚基类的作用？

首先明白二义性之一：

class A
{
    protected:
    int a;
}
class B: public A
{
    public；
    B()
    {
        a+=10;
        cout<<a;
       
    }
}
class C: public A
{
    public；
    C()
    {
        a+=20;
        cout<<a;
       
    }
}
class D: public B,public C
{
    D()
    {
        cout<<a;//这里出现了二义性，不知道是调用B的还是C的，也就是基类A是构造函数被两次调用
    }
}

这种二义性就是两个派生类调用了两次基类构造函数，所以基类拥有对象实例。

二义性1-解决办法-虚基类

把B,C定义成A的虚基类，那A的a只被调用一次，之后这个a是所有对像共有的

class A
{
    protected:
    int a;
    A()
    {
        a=10;
        cout<<a;
    }
}
class B: virtual public A//定义基类A为B的虚基类
{
    public；
    B()
    {
        a+=10;
        cout<<a;
       
    }
}
class C: virtual public A//定义基类A为C的虚基类
{
    public；
    C()
    {
        a+=20;
        cout<<a;
       
    }
}
class D: public B,public C
{
    D()
    {
        cout<<a;//a只被基类调用一次，所以下一个基类调用，就直接用现有的a，不在调用基类构造函数
    }
}
void main()
{
    D s();
}

程序运行结果，D类对象先调用B的构造函数，B的构造函数调用基类构造函数，a=10，然后调用B类构造函数，a=10+10=20，接下来重点，调用C类构造函数时，不在调用基类构造函数，直接使用a=20，执行C类的构造函数，a=20+20=40，最后调用D类的构造函数

虚基类构造函数

注意点: 1.虚基类A的初始化由最近派生类调用，最近派生类就是定义对象的类，在哪个类定义了对象，哪个类就是最近派生类，最近派生类对象会首先调用虚基类构造函数，所以以后其他的虚基类派生类就会跳过虚基类，不在执行虚基类的构造函数。

2.最近派生类中会先调用虚基类的构造函数，虚基类的构造函数优先级要高于非虚基类的函数

9.赋值兼容规则

答：就是将派生类对象赋值给基类，但反过来是不行的。只有公有继承才能成立

三种情况：

//直接赋值
Derived a;//派生类
Base b；//基类
b=a;

//定义基类指针
Derived a;
base *b;
*b=&a;//将派生类对象地址给基类指针

//定义基类引用
Derived a;
base &b;
&b=a;//将派生类对象地址与基类引用分享

10.纯虚函数的概念？抽象类的概念？

虚函数是什么:

答：为了解决一个问题：当基类指针指向派生类时，还是只调用基类同名函数的问题。就是基类，派生类有同名函数。

为了实现动态多态性，我们定义了虚函数，让基类指针指向派生类时也能执行派生类的同名函数。

纯虚函数:virtual 数据类型函数名（）=0，将基类的虚函数不赋其实际意义，只为派生类服务时调用。定义了纯虚函数就是抽象类，所以抽象类是不能定义对象的。

11.友元的特性

参照上面的友元

12.运算符重载的规则？哪个运算符不能被重载？

（1）只能对系统的已经定义的运算符进行重载，不能创造新的运算符

（2）三目运算符不能重载，运算符‘.’ ‘.*’ ‘::’ '?:'不能重载

13、模板？模板实例？

函数模板

template <class T>//就是这个T的数据类型是动态变化的，也就是它可以是char、int、long、string类型，就根据传过来的参数来判定T的类型。但是T的类型只能是一个，参数不能同时传递2个或以上不同个类型。
    //例子:
    #include <iostream.h>
    #include <math.h>
    T abs(T,x)//模板T
{
    return abs(x);
};
int a=8;
char b='C';
double c=2.588;
long d=2588888888;
abs(a);//T为int型
abs(b);//T为字符型
abs(c);//T为双精度型
abs(d);//T为长整型

类模板

template <class T>
template <class T1,class T2>
    //类模板也是一样的，也是动态运行时看T的类型变化

    #include <iostream.h>
    #include <math.h>
    class h
{
    private:
    T1 a;
    T2 b;
}
h<int,double>a(10,50.14585548);//T1-int型 T2-double型
h<char,long>a('A',854555555);//T1-cahr型 T2-long型

14、拷贝构造函数的概念？用法？

作用是用一个已经存在的对象去初始化新的对象

//定义
class Point
{
    int x;
    int y;
    public:
    Point(Point &a)
{
    this->x=a.x;
    this->y=a.y;
}
};
Point a1(40,50);
 Point a(a1);//调用拷贝构造函数a1的值初始化给a
 point b=a1;//调用拷贝构造函数a1的值初始化给b