cpp——与c比较之不同——函数 static const

函数

c++函数相较于c函数扩展了三个特性：

• 匿名参数
• 默认实参
• 函数重载

匿名参数

c++支持匿名参数

void eat(int)
{
    cout << "eat(int)" << endl;
}

void attack(int = 8)
{
    cout << "attack(int)" << endl;
}

默认实参

默认实参用于编译期缺失实参替换

默认实参规则：

• 默认实参可以是任何类型符合(表达式类型与形参类型兼容)的表达式，不一定是常量
• 可以为一个或多个形参指定默认实参，如果一个形参具有默认实参，那么它后面所有形参(如果还有)都必须有默认实参
• 同一源文件中每个形参至多只有一个函数声明指定默认实参
• 不同源文件中默认实参值可以不同

void eat(int food1 = 5, int food2 = 8)
{
    cout << "eat food " << food1 << " and " << food2 << endl;
}

void attack(int hurt = 3 + 5)
{
    cout << "attack hurt " << hurt << endl;
}

函数重载

函数定义&调用

函数定义

void eat(int food1, int food2)
{
    //...
    //...
}

函数调用

eat(5, 8);

经过c编译器编译后的汇编代码为：

函数定义

_sub_eat_:
           //...
           //...
           ret

函数调用

call _sub_eat_

c不支持函数重载，所以函数名全局唯一，用函数名来生成子过程名没有问题

c++支持函数重载，不能再利用函数名来生成子过程名了，否则生成的子过程名重复了，call指令不知道跳转到那一段汇编代码继续执行，c++的函数重载利用函数名+形参列表唯一确定函数，因此生成的子过程名也必须利用函数名+形参列表来生成

经过c++编译器编译后的汇编代码为：

函数定义

_sub_eat_int_int_:
           //...
           //...
           ret

函数调用

call _sub_eat_int_int_

函数指针

c不支持函数重载，通过函数名就可以找到函数入口地址，因此c函数指针不对形参类型做严格检查，形参类型可以为空或者完全精确match，形参类型为空时，通过函数指针调用时对实参不做任何检查，runtime时才能发现错误，形参类型不为空时，通过函数指针调用时会对实参做严格检查，但是函数返回值一定要完全match

void eat(int food1, int food2)
{
    //...
    //...
    printf("eat %d %d\n", food1, food2);
}

void fun_pointer()
{
    void (*pEat1)() = eat;
    void (*pEat2)(int, int) = eat;
    
    pEat1(5);
    pEat1(5, 8);
    pEat1(5, 8, 58);
    
    //pEat2(5);
    pEat2(5, 8);
    //pEat2(5, 8, 58);
}

c++支持函数重载，因此c++的函数指针必须指定函数形参，这样才能找到重载函数集合中的准确函数入口地址

void eat(int food1, int food2)
{
    //...
    //...
    printf("eat %d %d\n", food1, food2);
}

void fun_pointer()
{
    void (*pEat)(int ,int) = eat;
    
    pEat(5, 8);
    //pEat(5);
    //pEat(5, 8, 58);
}

static和类

• static修饰类数据成员：寄存于类作用域下的外部对象声明
• static修饰类函数成员：寄存于类作用域下的外部函数声明

class CAnimal
{
public:
    static int getTotalAnimal();
    
private:
    static int totalAnimal;
};

等价于

extern int getTotalAnimal();
extern int totalAnimal;

const

c++中const对象必须初始化，c中const对象可不初始化

修饰引用

引用的本质是const对象，类型为普通指针，而const引用的本质则是const对象，类型为const指针(指向const对象)

• int& ri等价于int* const ri
• const int& rci等价于 const int* const rci

int i = 5;
const int ci = 8;
    
int& ri1 = i;
//int& ri2 = ci;
    
const int& rci1 = i;
const int& rci2 = ci;

修饰类

class CDog
{
public:
    CDog();
    ~CDog();
    
public:
    void eat(int food);
    void attack(int hurt) const;
    
private:
    int food;
    const int hurt;
};

CDog从c角度理解为：

定义一个c struct

struct CDog
{
    int food;
    const int hurt;
};

声明含this隐含参数外部函数

void CDog(struct CDog* const this);
void ~CDog(struct CDog* const this);
void eat(struct CDog* const this, int food);
void attack(const struct CDog* const this, int hurt);

dog.eat(5)等价于eat(&dog, 5)

总结：

• 构造函数和析构函数不能定义为const函数，因为构造函数和析构函数的设计本意就是用来改变对象状态的，定义为const函数违背本意
• const数据成员的初始化只能在构造函数的初始化列表中进行，因为初始化列表属于初始化行为，不是赋值行为，不属于对const对象值的改变
• const函数成员的本质是修饰this参数，使this指向的对象状态不可修改，而this指向的就是自身，因此意味着const函数成员不可修改自身状态(自身数据成员)
• static数据成员可以使用const修饰，表示外部对象值不可修改
• static函数成员没有this参数，因此static函数成员不能定义为const函数，const不知道修饰谁
• 根据const指针不能转非const指针，非const指针可以转const指针规则，const对象只能调用const成员函数，非const对象可以调用const成员函数和非const成员函数