c++答疑解惑

• new malloc delete free 区别
  https://blog.csdn.net/TABE_/article/details/122179176

• const 作用

1. 要使一个变量的值不被改变，可以使用const. 通常在定义应该类变量，要进行初始化，因为在之后变没有机会赋值了。
2. 对于指针，可以指定指针为const, 也可指定指针所指向的数据为const, 也可以同时规定指针和数据都为const.
3. 对函数的形参规定const，代表在函数体内不能对变量进行改变。
4. 规定一个函数为const常函数，表示在函数体内不可以对类的成员进行改变。
5. 函数的返回值为const表示应该返回值不能成为一个“左值”。

• static 作用

1. 在函数内的static 变量只会被声明一次，下次在应该函数内访问时，得到的是上一次赋值的结果。
2. 在模块内的全局static变量只能被这一模块内的函数所访问，不能被模块外的函数访问。
3. 在模块内的static函数只能被模块内的函数所访问，不能被模块外的函数访问。
4. 类里的static 成员变量为整个类所有，对类的所有对象只有一份拷贝，必须进行初始化。
5. 类里的static 函数为整个类所有，不接受this指针，因此，只能在static函数里访问static成员变量。

• 指针各种定义的区别 const *, const int *, const int const *
  https://blog.csdn.net/m0_37806005/article/details/119111970

void modify(int &i) {
    i=2;
}

int main(int argc, char* argv[])
{
    const int i = 1;
    i=2; // 常量i有可修改
    
    modify(i); //常不可作为非常量参数
    int &a=i; // 同上
    const int &b=i; // 正确
    // 以上是引用的情况
    
    int c=2;
    
    const int *it1 = &i; // 指的是对应的值不可变
    *it1 = 3; // 内容只读
    it1 = &c; // 指向可改变


    int * const it2 = &c; // 指向不可变
    *it2 = 3; // 真实内容可变
    it2 = &c; // 指向不可改变

    int const *  it3 = &c; // 同 const int * 
    *it3 = 3; 
    it3 = &c; 
    return 0;
}

• 字符串内部数据结构
  char * data, int length.

• 函数定义
  void (*pf)(params…)
  数组形式
  v o i d ( ∗ p f ) [ ] ( p a r a m s ) 是 指 数 组 的 元 素 是 函 数 指 针 void (*pf)[](params) 是指数组的元素是函数指针 void(∗pf)[](params)是指数组的元素是函数指针

v o i d ∗ p f [ ] ( p a r a m s ) 是 指 数 组 p f 是 一 个 指 针 ， 指 向 一 个 数 组 void *pf[](params) 是指数组pf是一个指针，指向一个数组 void∗pf[](params)是指数组pf是一个指针，指向一个数组

• 引用的定义有其区别，与指针区别

• class 4个默认函数
  构造函数，析构函数，赋值函数，复制函数
  类的成员包括成员函数和数据成员。之前我们也都接触过了，这一节详细的看这两部分需要注意的地方。先看成员函数需要注意的地方：

1. 成员函数的声明必须在类体内，而定义可以放在类体内，也可以放在类体外。一般只有代码简短的成员函数才放在类体内定义。
   2.在类体内定义的成员函数是内联函数（inline），在类体外定义的成员函数是外联函数。内联函数我们学过的，就是适用于代码简短的函数，编译的时候将内联函数的代码替换调用的代码，也就是说内联函数不是被调用的，而是直接运行的。调用会浪费时间和系统资源，所以内联函数能够提高程序效率。
   3.类的外联函数可以转为内联函数，只需要在类体外实现的时候，在返回类型前面加inline就可以了。
   4.除了析构函数外，所有的成员函数都能重载，包括构造函数也能重载。析构函数就一个，这个上一节说过。

• c++内存管理

• class 权限修辞符号
  类的成员（包括成员函数和数据成员）都有一个属性，叫做访问权限，有三种：
  1.私有成员(private)：缺省情况下，一个类中的所有成员都是私有的。私有成员只能被类本身的成员函数访问，有元函数可以访问。并且不具有继承性，也就是子类也不能访问到私有成员。
  2.公有成员(public)：公有成员可以被类的成员函数使用，也可以被类外部的函数使用。
  3.保护成员(protected)：类的保护成员能被类及其派生类的成员函数和友员函数使用，具有继承性。简单说就是子类和友员可以访问，其他外部函数不能访问。

继承方式

• 纯虚函数，虚类，虚继承
  https://blog.csdn.net/amoscykl/article/details/85796850
  虚函数重写原理：类里面会有一个虚函数列表，当子类重写了函数时，会把函数的地址修改。
  如果一个类里有纯虚函数，则不可以实例化。
  virtual 关键字的函数优先使用子类实现的方法，如果没有加此关键字则使本类型的方法。

class A {
public:
    virtual void Call() {
        cout<<"CallA"<<endl;
    }
};

class B: public A {
 // private: 加上后 用A类也可以访问Call
    virtual void Call(){
        cout<<"CallB"<<endl;
    }
};


void outCall(A *a) {
    a->Call();
}

int main(int argc, char* argv[])
{
    A *a = new B();
    outCall(a);
    return 0;
}
输出 CallB

-----
class A {
public:
    virtual void Call() {
        cout<<"CallA"<<endl;
    }
};

class B: public A {
};


void outCall(A *a) {
    a->Call();
}

int main(int argc, char* argv[])
{
    A *a = new B();
    outCall(a);
    return 0;
}

输出 CallA

-----
class A {
public:
    void Call() {
        cout<<"CallA"<<endl;
    }
};

class B: public A {
    virtual void Call(){
        cout<<"CallB"<<endl;
    }
};


void outCall(A *a) {
    a->Call();
}

int main(int argc, char* argv[])
{
    A *a = new B();
    outCall(a);
    return 0;
}

输出 CallA