zoukankan      html  css  js  c++  java
  • 『C++』基础知识点

    一、基础知识

    1、C++编译流程

    以Unix系统编译中间文件为说明:

    .cpp—(编译预处理)—>.ii—(编译)—>.s—(汇编)—>.o—(ld,连接)—>.out

    2、#include

    作用于编译预处理阶段,将被include文件抄送在include所在位置,并会在相应位置写出调用栈,生成中间文件.ii,该中间文件可读

    include文件加引号表示先从当前目录寻找索引,加尖括号表示从编译器指定根目录索引,Unix默认为"~//usr/include"目录

    3、定义、声明、头文件

    .h头文件中只应存放三种代码:

    函数声明:没有大括号,形如void fun()

    变量声明:extern 变量名

    class、结构体定义

    extern表示声明一个全局变量

    声明只是提示编译器,存在这个东西,并没有定义出实体,不定义直接调用会报错。

    4、标准头文件结构

    #ifndef HEADER_FLAG

    #define HEADER_FLAG

    /*头文件*/

    #endif

    这是为了防止多次include同一个头文件时,每次都抄送到预编译文件中,造成文件过大、循环导入或者结构体定义重复以致报错(声明重复问题不大)。

    5、默认参数

    在声明中写默认参数,不在定义中给默认参数。

    6、调用函数过程

    本地变量进入堆栈(未必初始化)

    函数参数进入堆栈

    返回地址计入堆栈

    返回值进入寄存器(运行函数)

    pop掉参数

    返回值进入堆栈(返回地址,所以要pop掉参数,堆栈先进后出)

    7、内联函数

    在编译阶段优化,省略上一小结中复杂的堆栈操作,效果如下,

    汇编(伪)优化如下,

    注意,inline 函数名实际是一个声明,而非定义所以不需要额外声明。实际上以空间换时间(编译会将函数插入调用位置),编译器如果发现函数递归或者过于巨大,可能会拒绝inline操作,函数较小可能被自动inline,建议就是小函数inline(2-3行),超过20行的就不要inline了。

    相比于宏,inline可以做类型检查,给出debug提示,下图中C++会提示double的f(a)和%d不匹配,C会直接给出一个奇怪的值,

     8、const

    初始化之后不可修改,值得注意的是下图这种,指针和const,到底是地址(指针)还是地址中的内容(对象)是const

    重点在于const和*的位置顺序,下述代码中2、3两句等价,

    且const变量不能传给其他非const的指针(因为这样有可能造成修改),

    函数和const

    函数虚参加const表示函数内部不可修改该变量,对输入无要求

    return const 对接收函数返回的类型无要求

    class和const

    const 对象,此时我们不能保证class方法是否修改成员变量,又不能限制函数不能使用(class就没有意义了)

    const 对象 or 成员变量是const,要求成员变量必须有初始值,因为事后无法赋值

    main文件(编译时可以感知类声明文件),类声明文件,类定义文件:声明、定义(两个位置都需要添加)函数时后面添加const关键字如,int fun() const。

    下图运行结果为"f() const",

    实际构成了重载,

    void f(A* this)

    void f(const A* this)

     9、字符串

    char *s = "Hello World";  // 将代码段的字符串地址直接付给指针,所以后面尝试修改会报错(代码段不可修改),

                 // 应该在开头改写为const char *s

    char s[] = "Hello World";  // 数组被写入堆栈,将代码段的字符串拷贝到堆栈

    10、引用

    char& r = c;  // 引用可以做左值

    相当于给c取了一个别名,此时c、r绑定到同一实体。

    int x;int y;

    int& a = x;

    int& b = y;

    a = b;  // 等价x=y

    注意,引用无法取地址,即 int&* r 的写法是错误的,不过相对的,int*& p 是没问题的,指针可以被引用。

    class的成员变量是引用时

    此时只能使用initializer list的方式初始化引用对应的变量,如果在{}中使用m_y=a则表示将a复制给m_y对应的变量。

    函数返回引用时

    return一个全局变量,

    这个引用表示变量,不表示值,所以最后一句表示赋值。

    11、中间结果

    相当于Python中的“_”,i*3这样的结果会作为const int类型临时保存。

    二、class入门

    1、变量

    Field,成员变量,作用域为class的对象,类的函数中可以直接使用;class本身不能拥有变量,理解为声明一个变量(函数和变量不同,函数属于class而不是对象);

    parameters,函数参数;

    local variables,本地变量,作用域为本函数;

     后两者完全相同,本地存储,出来作用域则不存在该变量。

    关键字 this:一个指针,为当前对象的指针(指该次调用成员函数的对象的指针),

    经由指针this区分调用成员函数的不同实例,其原理如下:使用'实例对象.成员函数'来调用等价于直接调用该函数并将对象指针作为首个参数输入,即:成员函数(this),原理和python一致,成员函数实际上有一个默认存在的参数输入,接收实例指针

    2、构造和析构

    在C++中,class实例化时成员变量不会初始化,仅仅寻找到一块足够大的地址(java会清空地址内数据)。VS会在debug时为未初始化空间填充0xcd,用于排查(0xcd0xcd在国标码中为‘烫’)。

    constructor:构造函数,初始化对象时自动执行(相当于python中的__init__)

    函数名和class名相同

    没有返回类型

    destructor:析构函数,退出对象所在scope时自动执行

    函数名为'~'加构造函数名

    没有返回类型

    不可以有参数

    有关‘{}’,表示scope,如下代码中,进入‘{’后会执行Tree的构造函数,退出‘}’前,本scope内资源回收,会自动执行析构函数

    数组、结构体、使用构建函数的class初始化方式对比:

    Y经由构建函数Y()间接将f、i赋值,顺便一提,数组b后面未指定元素会被初始化为0

    default constructor:无参数构建函数,见下右的第二行会报错,因为构建y2有两个元素,而第二个元素会调用default constructor,但实际上constructor需要参数,所以会报错:

    :

    3、scope和存储空间

    编译器在‘{}’开始的位置会分配好空间,而在运行到相关定义时才会真正的运行构造函数。

    如下图,某些情况下编译会出错,因为一旦goto成功,则x1不会被构建,相应的退出‘{}’时,析构函数执行会失败。

    4、动态分配空间

    new:制造对象,类似malloc;分配空间、调用构造函数(对于class),返回地址

    使用一张表,记录下每次申请的内存大小和对应的地址

    delete:收回空间,类似free;析构对象(对于class)、回收空间;它有两种用法,如下:

    delete p :普通用法

    delete[] p :一般来说new p[]时,需要使用这个,会将所有对象的析构函数分别调用,否则回收内存正常,但只调用指针直接指向的对象的析构

    5、访问控制

    public:任何人可以访问

    private:成员函数可以访问 ,注意对class来讲,同一个class不同对象可以互相访问私有变量,如下代码,p[0]是可以访问b的私有变量的

    friends:声名一个函数/class等,使之可以访问自己(本class的任何实例)的私有变量

    下面代码涉及两个知识点:1、friends声明在class内部;2、结构体可以前向声明(开头的X),用于在结构体Y定义中占位。

     

    protected:自己及子类可以访问

    6、struct vs class

    未指定访问控制属性的变量、函数,class默认为private,struct默认public

    7、初始化list

    初始化后才执行构造函数(大括号中语句)

    在大括号中赋值的话会先默认初始化变量,然后赋值;初始化list的方式直接用目标值初始化变量

    8、成员函数和inline

    在class内部给出了body的成员函数,视为内联函数。

    三、父类子类

    1、组合和继承

    组合:已有类作为新的类的成员

    继承:改造类,class B: public A {},意为B类为A类子类 

         父类的private,在子类中存在,但是不能直接访问(需要使用父类的public方法),需要使用protected声明。

    另一点值得注意的是,由于构造函数不可以直接调用, 调用父类的构造函数方式需要使用初始化list方法,而且必须最先构造父类(如果父类构造函数有参数),构造先父后子,析构先子后父:

    2、覆盖(override)、重载(overload)、隐藏

    overload

    在同一作用域中,函数名相同,参数列表不同,返回值可同可不同的函数,编译器会根据传入参数决定调用哪个函数,注意仅返回值不同不能构成overload关系。

    override

    又叫覆盖,是指不在同一个作用域中(分别在父类和子类中),函数名,参数个数,参数类型,返回值类型都相同,并且父类函数必须有virtual关键字的函数,就构成了重写(协变除外)。协变:协变也是一种重写,只是父类和子类中的函数的返回值不同,父类的函数返回父类的指针或者引用,子类函数返回子类的指针或者引用。

    virtual:子类的同名同参函数之间有联系(继承树中某一个函数是virtual的,子类的该方法都是virtual的)。

    重定义

    又叫隐藏,是指在不同的作用域中(分别在父类和子类中),函数名相同,不能构成重写的都是重定义(重定义的不光是函数,还可以是成员变量),隐藏和覆盖不同,被隐藏的父类成员可以通过子类.父类::成员的方式调用。

    3、向上造型upcasting

    子类对象可以被传给父类对象指针,如下图所示,

    这是由于C++的class类似于C的结构体,实际上是一个指针指向一块有特定内容排列顺序的内存,子类只会在父类的内存规划上向后扩充,不会更改父类已经规划好的部分。如果有子类方法隐藏了父类方法,向上造型后会隐藏失效,此时的对象指针仅能识别父类原有的模块。

    类似地,也有向下造型,不过可能会出错。

    Employee是Manager的父类

    4、多态

    本小节摘抄自文章:C++ 多态的实现及原理

    想要理解多态,需要区分函数和虚函数的区别(内存上的位置差异),并要理解向上造型的概念,了解了前面两点,就了解了动态绑定、静态绑定的区别,对于多态产生的种种现象就能够从机理上给出自己的解释。

    virtual虚函数内存机制

    上面提到过,virtual是让子类与父类之间的同名函数有联系,这就是多态性,实现动态绑定。

    任何类若是有虚函数就会比正常类大一点,所有有virtual的类的对象里面最头上会自动加上一个隐藏的,不让我知道的指针,它指向一张表,注意,该表对于同一个class的不同对象是同一个,不同class(指父类子类)的表不同。这张表叫做vtable(虚表),vtable里是所有virtual函数的地址,对于下面代码,

    class Shape {
    public:
        Shape();
        virtual  ~Shape();
        virtual void render();
        void move(const pos&);
        virtual void resize();
    protected:
        pos center;
    };
    

     其内存分布如下:

    我们看一下其子类的内存分布:

    class Ellipse : public Shape{
    public:
        Ellipse (float majr, float minr);
        virtual void render();
    
    protected:
        float major_axis;
        float minor_axis;
    };
    

     

    这里的resize沿用了shape的成员函数。

    多态实现逻辑

    看如下代码,

    #include "stdafx.h"
    #include <iostream> 
    #include <stdlib.h>
    using namespace std; 
    
    class Father
    {
    public:
        void Face()
        {
            cout << "Father's face" << endl;
        }
    
        void Say()
        {
            cout << "Father say hello" << endl;
        }
    };
    
    
    class Son:public Father
    {
    public:     
        void Say()
        {
            cout << "Son say hello" << endl;
        }
    };
    
    void main()
    {
        Son son;
        Father *pFather=&son; // 隐式类型转换
        pFather->Say();
    }
    

    输出的结果为:

    我们在main()函数中首先定义了一个Son类的对象son,接着定义了一个指向Father类的指针变量pFather,然后利用该变量调用pFather->Say().估计很多人往往将这种情况和c++的多态性搞混淆,认为son实际上是Son类的对象,应该是调用Son类的Say,输出"Son say hello",然而结果却不是.

    从编译的角度来看:

    c++编译器在编译的时候,要确定每个对象调用的函数(非虚函数)的地址,这称为早期绑定,当我们将Son类的对象son的地址赋给pFather时,c++编译器进行了类型转换,此时c++编译器认为变量pFather保存的就是Father对象的地址,当在main函数中执行pFather->Say(),调用的当然就是Father对象的Say函数

    从内存角度看:

        

    Son类对象的内存模型如上图

    我们构造Son类的对象时,首先要调用Father类的构造函数去构造Father类的对象,然后才调用Son类的构造函数完成自身部分的构造,从而拼接出一个完整的Son类对象。当我们将Son类对象转换为Father类型时,该对象就被认为是原对象整个内存模型的上半部分,也就是上图中“Father的对象所占内存”,那么当我们利用类型转换后的对象指针去调用它的方法时,当然也就是调用它所在的内存中的方法,因此,输出“Father Say hello”,也就顺理成章了。

    正如很多人那么认为,在上面的代码中,我们知道pFather实际上指向的是Son类的对象,我们希望输出的结果是son类的Say方法,那么想到达到这种结果,就要用到虚函数了。

    前面输出的结果是因为编译器在编译的时候,就已经确定了对象调用的函数的地址,要解决这个问题就要使用晚绑定,当编译器使用晚绑定时候,就会在运行时再去确定对象的类型以及正确的调用函数,而要让编译器采用晚绑定,就要在基类中声明函数时使用virtual关键字,这样的函数我们就称之为虚函数,一旦某个函数在基类中声明为virtual,那么在所有的派生类中该函数都是virtual,而不需要再显式地声明为virtual。

    代码稍微改动一下,看一下运行结果

    #include "stdafx.h"
    #include <iostream> 
    #include <stdlib.h>
    using namespace std; 
    
    class Father
    {
    public:
        void Face()
        {
            cout << "Father's face" << endl;
        }
    
        virtual void Say()
        {
            cout << "Father say hello" << endl;
        }
    };
    
    
    class Son:public Father
    {
    public:     
        void Say()
        {
            cout << "Son say hello" << endl;
        }
    };
    
    void main()
    {
        Son son;
        Father *pFather=&son; // 隐式类型转换
        pFather->Say();
    }
    

    我们发现结果是"Son say hello"也就是根据对象的类型调用了正确的函数,那么当我们将Say()声明为virtual时,背后发生了什么。

    编译器在编译的时候,发现Father类中有虚函数,此时编译器会为每个包含虚函数的类创建一个虚表(即 vtable),该表是一个一维数组,在这个数组中存放每个虚函数的地址,

    那么如何定位虚表呢?编译器另外还为每个对象提供了一个虚表指针(即vptr),这个指针指向了对象所属类的虚表,在程序运行时,根据对象的类型去初始化vptr,从而让vptr正确的指向了所属类的虚表,从而在调用虚函数的时候,能够找到正确的函数,对于第二段代码程序,由于pFather实际指向的对象类型是Son,因此vptr指向的Son类的vtable,当调用pFather->Son()时,根据虚表中的函数地址找到的就是Son类的Say()函数.

    正是由于每个对象调用的虚函数都是通过虚表指针来索引的,也就决定了虚表指针的正确初始化是非常重要的,换句话说,在虚表指针没有正确初始化之前,我们不能够去调用虚函数,那么虚表指针是在什么时候,或者什么地方初始化呢?

    答案是在构造函数中进行虚表的创建和虚表指针的初始化,在构造子类对象时,要先调用父类的构造函数,此时编译器只“看到了”父类,并不知道后面是否还有继承者,它初始化父类对象的虚表指针,该虚表指针指向父类的虚表,当执行子类的构造函数时,子类对象的虚表指针被初始化,指向自身的虚表。

  • 相关阅读:
    BeautifulSoup_第一节
    第一个python爬虫——保存淘宝mm图片
    面试题:css(一)
    面试:HTML(二)
    websocket
    面试题:HTML篇(一)
    HTML5遗忘知识点(一)
    webpack热更新原理
    webpack按需加载
    什么是process.env?
  • 原文地址:https://www.cnblogs.com/hellcat/p/9669998.html
Copyright © 2011-2022 走看看