C++的内联函数

宏函数的缺点

#include<bits/stdc++.h>

#define ADD(x,y) ((x)+(y))
#define ADD_One(x,y) (x*y)

using namespace std;

int main()
{
    cout<<ADD("asd",1)<<endl; //输出：sd  原因：宏定义没有类型检查
    
    cout<<ADD_One(1+2,3+4)<<endl; //输出：11  原因：宏定义有二义性
    
    return 0;
}

内联函数的定义：

以 inline 修饰的函数叫做内联函数，编译时 C++ 编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率。

如果是一个几十行的函数，函数本身执行就很耗时，那调用函数、创建栈帧（每个栈帧对应着一个未运行完的函数。栈帧中保存了该函数的返回地址和局部变量。其实就是函数运行时开辟的函数栈。）的一两行可以忽略不计；但是如果一个函数本身就一两行，因为调用函数本身而产生的那一部分消耗，就格外突出，而宏或者内联的提前替换就显得格外优秀，提高了效率。

inline int add(int a,int b)
{
	return a+b;
}

特点

• inline 是一种以空间换时间的做法，省去调用函数、建立栈帧的额外开销，但是如果代码很长（一般是 10 行左右，具体取决于编译器），或者有递归函数，即使函数前面声明了 inline，那么编译器也不会让该函数成为内联函数。
• inline 对于编译器而言只是一个建议，编译器归自动优化，如果定义的函数很长或者递归函数等等，编译器优化时会忽略掉内联。
• inline 不可以声明和定义分离，.h 文件中使用 inline 声明内联函数 .cpp 文件中不使用 inline 定义函数，会报错链接错误。

静态成员变量

我们可以使用 static 关键字来把类成员定义为静态的。当我们声明类的成员为静态时，这意味着无论创建多少个类的对象，静态成员都只有一个。

static 成员变量和普通 static 变量一样，都在内存分区中的全局数据区分配内存，到程序结束时才释放。这就意味着，static 成员变量不随对象的创建而分配内存，也不随对象的销毁而释放内存。而普通成员变量在对象创建时分配内存，在对象销毁时释放内存。

静态变量初始化时可以赋初值，也可以不赋值。如果不赋值，那么会被默认初始化为0。全局数据区的变量都有默认的初始值0，而堆区、栈区变量的默认值是不确定的，系统会给这个变量自动赋一个随机的值。

• 静态成员变量属于整个类所有，所有对象共享类的静态成员变量
• 静态成员变量需要在类外初始化（必须初始化，可以不赋值）
• 可以通过类名直接访问公有静态成员变量
• 可以通过对象名访问公有静态成员变量
• 静态成员变量在程序内部位于全局数据区（静态区）
• 静态成员变量的生命期不依赖于任何对象，与程序的生命周期一致
• 静态成员变量不会被继承，父类和子类共享静态成员变量

#include<iostream>

using namespace std;

class A
{
public:
    static int num;
    A()
    {
        num++;
    }
};

int A::num=0; //静态成员变量必须在类外初始化，所有对象共享同一个静态成员变量

class B :public A
{
    
};

int main()
{
    A a;
    a.num++;
    A b;
    b.num++;
    cout<<a.num<<' '<<b.num<<endl;
    A::num=5; //因为静态成员变量属于类所有，所有共有的静态成员变量可以直接通过类名访问，也可以直接通过对象名访问
    cout<<a.num<<endl;
    a.num++;
    cout<<B::num<<endl; //静态成员变量不会被继承，父类和子类共享静态成员变量
    return 0;
}

静态成员函数

• 定义静态成员函数，直接使用 static 关键字修饰即可，静态成员函数属于整个类所有，没有 this 指针
• 静态成员函数只能直接访问静态成员变量和静态成员函数（因为没有 this 指针，因为访问普通的成员变量和成员函数前面都隐含 this）和类外部的其他函数
• 可以通过类名直接访问类的公有静态成员函数
• 可以通过对象名访问类的公有静态成员函数

#include<iostream>

using namespace std;

class A
{
public:
    int c;
    static int b;
    void s()
    {
        c=1; //this->c=1;
    }
    static void sta_d(){}
    static int sta_fun(int a)
    {
        sta_d(); //静态成员函数可以调用静态成员函数
        b=2; //静态成员函数可以调用静态成员变量
        
        //s(); //error s()相当于 this->s()，但是静态成员函数里面没有 this，因为他属于整个类，不属于具体某个对象
        //c=3; //error 因为非静态成员变量需要创建对象的时候才能分配空间，然而静态成员函数不需要创建对象就已经存在了，所以有冲突。
        cout<<"静态成员函数"<<endl;
        return 0;
    }
};
int A::b=1;
int main()
{
    A::sta_fun(1); //通过类名 + 作用域直接访问类的公有静态成员函数
    A a;
    a.sta_fun(1); //通过对象直接访问类的公有静态成员函数
    return 0;
}