C++基础02---函数的特性、内联函数、const、mutable

1. 函数的参数与返回值

1.1 函数的参数

（1） 函数声明时，可以只有形参类型，没有形参名。
（2）函數定义中，如果形参名用不到，可以不给形参名，只给其类型。

void func(int, int);  //函数声明

void func(int a, int) //函数定义
{
    a = 13;
    return;
}

1.2 函数的返回值

（1）前置返回类型：函数的返回类型在函数之前
（2）后置返回类型：函数的返回类型在函数之后

auto func(int, int) -> void;  //函数声明

auto func(int a, int) -> void //函数定义
{
    a = 13;
    return;
}

1.3 函数的注意事项

（1） 一个返回值为空的函数可以返回另一个返回值为空的函数

void func1()
{

}
void func2()
{
    return func1();
}

（2）不可返回函数中局部变量的地址

int *func1()
{
    int tmp = 5;
    return &tmp; //不可以，tmp为局部变量，函数执行完后，tmp的内存会被系统回收
}

（3）引用作为函数的形参传递

void func1(int &num)
{
    num = 188;
}

int main(){

    int n = 8;
    func1(n);
    cout << n << endl;  //188,引用作为形参传递时会改变行参变量的实际值
}

2. 内联函数

2.1 内联函数的使用

1. 使用场景：函数体很小，且被频繁调用。
2. 使用方法：在函数定义前添加inline，使该函数变为内联函数。
3. 使用注意：
   （1）编译器在编译阶段将内联函数的调用动作替换为函数的本体，提高效率。
   （2）inline只是开发者对编译器的一个建议，编译器进不进行操作取决于编译器的诊断功能，我们无法控制。
   （3）内联函数的定义必须放在头文件（.h），这样用到该内联函数的cpp文件都可通过#include把内联函数的源代码包含进来。
   （4）可能造成代码膨胀，所以内联函数体要尽量小。

inline int func(int a)
{
    return a;
}

int main(){
    int a = func(5);  //替换为int a = 5;
}

2.2 在类定义中实现的成员函数被当作内联函数

#ifndef DAY02_TIME_H
#define DAY02_TIME_H

//类的声明
class Time
{
public:
    int m_Hour;  //成员变量
public:
    Time(int hour);
public:
    void addHour(int tmpHour)  //在类定义中实现成员函数，此成员函数被当作内联函数处理
    {
        m_Hour += tmpHour;
    }
};

#endif //DAY02_TIME_H

#include <iostream>
using namespace std;
#include "Time.h"

Time::Time(int hour)
{
    m_Hour = hour;
}

int main() {
    Time time(10);
    cout << time.m_Hour << endl;  // 10
    time.addHour(5);
    cout << time.m_Hour << endl;  //15
}

3. const

3.1 const char *p, char const *p, char * const p三者的区别

（1）const char *p 与char const *p等价
即指针p指向的内存内容无法通过p修改

int main(){
    char str[] = "I love China";
    const char* p = str; //p指向的东西不能通过p来修改
    // *p = 'Y';    //错误
    p ++;
    p++;
    // *p = 'Y';    //错误
    str[0] = 'Y';   //str可以修改
    cout << str; //Y love China
}

（2）char * const p
p一旦指向了一个东西，就不可以再指向其它东西。

int main(){
    char str[] = "I love China";
    char * const p = str; //p一旦指向一个东西，就不可以再指向其他东西
    //p++;  //错误，p无法指向其他东西
    *p = 'Y'; // 正确，p的内容可以修改
    cout << p << endl;  //Y love China
}

（3）const char *const p
p指向的东西不可以修改，同时p不可以指向其他东西

int main(){
    char str[] = "I love China";
    const char * const p = str; //p指向的内容不可以改变，p也不可以再指向其他东西
    //p++;  //错误，p无法指向其他东西
    //*p = 'Y'; // 错误，p的内容不可以修改
}

3.2 const int & a

a的内容不可以通过a修改

int main(){
    int i = 100;
    const int &a = i; //a的内容不可以通过a修改
    // a = 500; //错误
    i = 600; //正确
}

3.3 函数形参中的const

为了不让在函数中改变形参的值，添加const

void func1(const int &num)
{
    // num = 188; //错误
}

int main(){

    int n = 8;
    func1(n);  //形参值无法被修改，实参指也不会被误修改
}

把形参写成const的好处：
（1）可以防止无意中修改了形参值导致实参指被修改。
（2）实参引用可以更灵活

void func1(const int &num)
{
    return;
}

int main(){

    const int n = 8;
    func1(n); //const int型的变量也可传递 
}

3.4 成员函数末尾的const

成员函数末尾的const表示：该成员函数不会修改对象里任何成员变量的值，这种成员函数也被称为“常量成员函数”。

#ifndef DAY02_TIME_H
#define DAY02_TIME_H

//类的声明
class Time
{
public:
    int m_Hour;  //成员变量
public:
    Time(int hour);
public:
    void addHour(int tmpHour) const;
};

#endif //DAY02_TIME_H

#include <iostream>
using namespace std;
#include "Time.h"

Time::Time(int hour)
{
    m_Hour = hour;
}

void Time::addHour(int tmpHour) const  //成员函数的声明和定义都要加const
{
//    m_Hour += tmpHour; //错误，不可修改对象里成员变量的值
//    m_Hour = 5;  //错误，不可修改对象里成员变量的值
}

int main() {
    Time time(10); 
}

3.5 const 成员对象

（1）const类型的成员对象只能调用const类型的成员函数。
（2）const类型的成员函数既可被const对象调用也可被非const对象调用。

#ifndef DAY02_TIME_H
#define DAY02_TIME_H

//类的声明
class Time
{
public:
    int m_Hour;  //成员变量
public:
    Time(int hour);
public:
    void func1() const;
    void func2();
};

#endif //DAY02_TIME_H

#include <iostream>
using namespace std;
#include "Time.h"

Time::Time(int hour)
{
    m_Hour = hour;
}

void Time::func1() const  //成员函数的声明和定义都要加const
{
    cout << "调用func1() const" << endl;
}

void Time::func2()
{
    cout << "func2()" << endl;
}

int main() {
    const Time time1(10);
    time1.func1(); //const对象可以调用const成员函数
//    time1.func2(); //const对象不可调用非const成员函数
    Time time2(12);
    time2.func1(); // 非const对象可以调用const成员函数
    time2.func2(); //非const对象可以调用非const成员函数
}

4. mutable

mutable（不稳定，易改变的意思），const的反义词。
用mutable修饰的成员变量永远处于可以被修改的状态，即便是在const结尾的成员函数中，也可以被修改。

#ifndef DAY02_TIME_H
#define DAY02_TIME_H

//类的声明
class Time
{
public:
    mutable int m_Hour;  //成员变量
public:
    Time(int hour);
public:
    void addHour(int tmpHour) const;
};

#endif //DAY02_TIME_H

#include <iostream>
using namespace std;
#include "Time.h"

Time::Time(int hour)
{
    m_Hour = hour;
}

void Time::addHour(int tmpHour) const  //成员函数的声明和定义都要加const
{
    m_Hour += tmpHour;  //m_Hour为mutable类型，可以被修改
}

int main() {
    const Time time1(10);
    time1.addHour(5);
    cout << time1.m_Hour << endl;
}