c++期末复习_C_内存溢出

文章目录

- c++期末复习
- - - 1.c++与c的关系（面向对象、面向过程）
    - 2. 引用的定义和使用
    - 3.调用重载函数的根据
    - 4.调用对象数组，构造函数被调用几次？
    - 5.对象成员调用构造函数的顺序
    - 6.友元函数是不是成员函数？
    - 7.Delete删除对象，析构函数和释放内存顺序？
    - 8.虚基类的作用？
    - - 二义性1-解决办法-虚基类
      - 虚基类构造函数
    - 9.赋值兼容规则
    - 10.纯虚函数的概念？抽象类的概念？
    - 11.友元的特性
    - 12.运算符重载的规则？哪个运算符不能被重载？
    - 13、模板？模板实例？
    - - 函数模板
      - 类模板
    - 14、拷贝构造函数的概念？用法？
    - 15、静态数据成员的概念？
    - 16、类和对象的关系？
    - 20、多态性？有几种？

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 
    #include 
    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 
    #include 
    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

15、静态数据成员的概念？

静态成员就是一个类它有一个公有成员，在类中只有一份拷贝，是所有对象所共享的，静态成员函数可以直接访问类的静态成员，但是不能直接访问非静态成员，只能通过对象访问，没有this指针记住这一点

详细请看https://blog.csdn.net/qq_43769572/article/details/89529633?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165423083616781435424383%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=165423083616781435424383&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-1-89529633-null-null.142^v11^pc_search_result_control_group,157^v13^control&utm_term=静态数据成员初始化&spm=1018.2226.3001.4187

16、类和对象的关系？

类是具有相同属性和行为的对象的集合

对象则是类的实例

属性—数据成员；行为—函数成员（成员函数

20、多态性？有几种？

两种：静态多态性和动态多态性

欢迎分享，转载请注明来源：内存溢出

原文地址: https://outofmemory.cn/langs/1324062.html