C++ 学习笔记（三）—— 入门+类和对象

1、内联函数（inline）

内联函数主要是解决C语言的宏的缺陷提出来的；

宏的缺陷：

1）容易出错，语法坑很多；

2）不能调试；

3）没有类型安全的检查；

宏的优点：

1）没有类型的严格限制；

2）针对频繁调用小函数，不需要再建立栈帧，提高了效率；

// 内联函数的使用示例
inline int add(int x, int y)
{
    return x + y;
}

int main()
{
    add(1, 2);  // 在debug模式下不会展开，方便调试;
    // 但是在release版本下可以展开；
    // 不像宏一样只是单纯的替换，减少了语法坑；
    // 内联函数虽然有诸多好处，但是容易导致目标文件过大，因此一般只将很小的函数设为内联；
    // 有一些编译器会自动识别，过大和递归的函数设置为内联会被编译器忽略；

    // 内联函数不能声明和定义分离；
    // 因为内联是在汇编的时候就已经要展开了，如果声明和定义分离就要在机器语言链接的时候才能关联；
    // 链接的符号表里内联函数不会存在，编译器也默认在之前就已经展开了；
    // 因此会报链接错误；
}

2、C++11语法糖

1）auto

根据等式右边的值自动推导左边的值的类型；该方案在常规情况下价值比较低，只有在类型名字很长的时候才能体现它的价值；

比如：std:: vector<std::string>::iterator oo = v.begin(); ------>auto oo = v.begin();

但需要注意auto不能作为函数的参数也不能用来声明数组；

小扩展：

如果用着用着不记得类型是啥了，可以通过typeid(变量).name()返回类型字符串；

2）范围for

int main()
{
    int array[] = {1, 2, 3, 4, 5};
    // 传统遍历数组的方法
    for(int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
        cout<< array[i] << " ";
    cout << endl;
    // 范围for用法
    // 这里是把array里的值赋值给e哦，所以改变e是不会改变array里面的值的；
    for(auto e : array)  // 这里不是非得用auto，用int也可以，只是auto比较通用比较方便
    {
        cout << e << " ";
    }
    cout << endl;
        return 0;
}

void func(int array[])
{
    // 此处会报错哦，因为此处array看起来是数组，其实是指针啦，范围for不支持；
    for(auto e : array)  
    cout << e << endl;
}

3）空指针nullptr

NULL实际是一个宏，在传统的C头文件（stddef.h）中，可以看到：

#define NULL 0 （C++自己定义的，C语言没有）

因此在有些地方，会被识别为字面常量0，也容易导致一些错误的出现，如：

void func(int p)
{
    cout << "int" << endl;
}

void func(int* p)
{
    cout << "int*" << endl;
}

func(NULL);  // 此处会显示"int"而不是"int*"
//为了解决这种错误，引入nullptr代表空指针；

3、 类和对象

之前有说过，在C++中兼容的结构体，本质上已经升级为了类，但是纯正的类，更喜欢用class作为定义类的关键字；而且，struct和class还是有一定的区别的，主要就是在访问限定符的使用上。

1）访问限定符

访问限定符：public（公有）、protected（保护）、private（私有）【目前暂时可以将保护和私有看作是一样的】------公有在类的外面可以访问，保护和私有只能在类里面访问；

class Stack
{
// 成员函数
void Init()
{
    a =nullptr;
    top = capacity = 0;
}

void Push(int x)
{
// 扩容判断
    if(top = capacity)
    {
        size_t newcapacity = capacity == 0 ？4 : capacity * 2;
        a = (int* )realloc(a, sizeof(int)*newcapacity);
        capacity = newcapacity;
    }

    // 插值
    a[top++] = x;
}

    // 成员变量
    int* a;
    int top;
    int capacity;
}

int main()
{
    Stack ss;
    ss.Init();
    ss.Push(1);  // 此处都会报错哦，error：访问私有数据；
    //  修改的方法，要不然把class改成struct，要不然就在需要外部访问的成员前加"public:"修饰；
    //  访问限定符的修饰范围是从访问限定符开始到下一个访问限定符/结束；
    //  class的默认访问限定是私有的哦，所以没有加public都是私有的都不能访问哦~
    //  访问限定符只限制类外访问，类中访问无限制；
    return 0;
}

// 类也可以声明和定义分离
// test.h
class Stack
{
public:
    // 成员函数
    void Init();
    void Push(int x);
private:
    // 成员变量
    int* a;
    int top;
    int capacity;
}

//  test.cpp
void Stack::Init()
{
    a =nullptr;
    top = capacity = 0;
}

void Stack::Push(int x)
{
    // 扩容判断
    if(top = capacity)
    {
        size_t newcapacity = capacity == 0 ？4 : capacity * 2;
        a = (int* )realloc(a, sizeof(int)*newcapacity);
        capacity = newcapacity;
    }
    // 插值
    a[top++] = x;
}

小扩展：
1）之前有提到过，一个语句如果要用一个函数或者一个变量，都是去之前的也就是上面的语句中查找，如果需要用到的函数或者变量在这个语句之后定义，就会出现找不到的情况，这种的话需要提前写一个声明才可以。
但是类里面的话，我们一般习惯把成员函数写在上面，成员变量写在下面，这种写法却不会出现找不到的情况，因为类是一个整体，所以里面的变量和函数无关顺序；
2）还需要注意，在类里面定义的成员函数默认就是内联函数，这一点后面会具体说；
3）成员的命名习惯：为了避免引用参数和成员变量同名导致错误的产生，比如时间类：

class Date
{
public：
    void Init(int year, int month, int day)
    {
    year = year;  //  此处虽然不会报错，但是也并不会被正确的初始化，因为局部优先，会变成参数自己赋            值给自己，而不会赋值给成员变量
    //  因此，成员变量一般命名为"_year"、"year_"；该方法虽然不是必须的，但是是约定俗成的；
    }
private:
    int year;
    int month;
    int day;
}

2）类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类外定义成员时，需要使用：：作用域操作符指明成员属于哪个类域；------ 这个在声明和定义分开的部分已经举过例子了；

// 以下脑洞大开的用法
class Date
{
public：
    void Init(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
}

int main()
{
    Date::_year;
    Date._year;  //  都是非法语句哈
    //  因为类里面的成员变量设置的地方只是一个声明，不是定义；
    //  无法访问一个声明里面的变量；
}

3）类的实例化