C++ 二.从C到C++

1. 引用 reference

1.1 概念

引用与指针类似，但是使用更加简便，功能更加简单，可以认为引用是一个变量的“别名”，对引用进行操作与直接操作变量完全相同。

引用引入了对象的一个同义词（“别名”）。

定义引用的表示方法与定义指针相似，只是用&代替了*。

引用（reference）是c++对c语言的重要扩充。

引用就是某一变量（目标）的一个别名，对引用的操作与对变量直接操作完全一样。

引用的声明方法：类型标识符 &引用名=目标变量名；

#include <iostream>

using namespace std;


int main()
{
    int a = 100;
    int& b = a; // b是a的引用
    b++;
    cout << a << " " << b << endl; // 101 101
    cout << &a << " " << &b << endl; // 0x61fe88 0x61fe88

    return 0;
}

1.2 性质

1. 可以改变引用的变量值，但是不能再次成为其它变量的引用。

int& b = a; // b是a的引用
    int c = 200;
    b = c; // 赋值操作
//    &b = c; //错误
//    int& b = c; //错误

2. 声明引用时，必须对其进行初始化。

//    int& b;   //错误
//    b = a;     //错误

3. 声明引用时初始化的值不能是NULL

//    int& b = NULL; 错误

4. 声明引用时，初始化的值如果是纯数值，需要给引用增加const关键字修饰，表示该引用是常引用，这样的引用不能改变其数值。

//    int& b = 100; 错误
    const int& b = 100;

5. 可以将变量引用的地址赋值给一个指针，此时指针指向的还是原来的变量。

    int a = 10;
    int& b = a;
    int* c = &b; // 指针c指向b,相当于直接指向a

6.可以对指针建立引用。

int a = 10;
    int* p = &a; // 指针p指向a
    int*& t = p; // t是p的引用

7. 可以使用const对引用进行修饰，此时虽然不能直接改变引用的值，但是可以间接改变原变量值。

int a = 1;
    const int& b = a; // b是a的常引用
//    b++; 错误
    a++;

1.3 引用参数

交换ab：

/**
 * @brief swap1 交换失败
 */
void swap1(int a,int b)
{
    a = a^b;
    b = a^b;
    a = a^b;
    cout << a << " " << b << endl;
}
/**
 * @brief swap2 交换成功，但是繁琐
 */
void swap2(int* a,int* b)
{
    *a = *a^*b;
    *b = *a^*b;
    *a = *a^*b;
}

/**
 * @brief swap3 交换成功
 */
void swap3(int& a,int& b)
{
    a = a^b;
    b = a^b;
    a = a^b;
}


int main()
{
    int a = 1，b=2;
    swap1(a,b);
    cout << a << " " << b << endl; // 1 2

    swap2(&a,&b);
    cout << a << " " << b << endl; // 2 1

    swap3(a,b);
    cout << a << " " << b << endl; // 1 2

    return 0;
}

当大型对象作为参数传递给函数时，使用引用参数可以使传递的效率提高，

因为引用不产生对象(副本)。

引用参数应该在能被定义为const的情况下，尽量定义const，以达到引用的安全性。

void show(const int& a)
{
    cout << a << endl;
}

2. 赋值（掌握）

C++中除了可以使用=赋值外，还可以使用下面的方式赋值。

int a(1); // 给a赋值1
int b(a); // 给b赋值a

强制类型转换

C语言中强制类型转换的格式为：（类型名）（表达式），例如 (double)a 是把a强转为double类型。

C++还增加了以下形式：类型名（表达式）

C++11中增加了数据窄化的写法与提示。

double a = 3.14;

    int b(a); // 传统C++写法
    int c{a}; // C++11写法：给出警告
    cout << b << endl;
    cout << c << endl;

3. 键盘输入（熟悉）

在C++中可以使用cin来获得键盘输入，也支持连续输入，也在头文件iostream里。连续输入的内容可以使用空格或回车来分割。

cin输入的字符串类型是string，这是C++的字符串类型。

string s; // 创建一个内容为空的字符串变量
    cout << s << endl; // 无输出结果
    int i;
    cout << "请输入一个字符串和一个数字：" << endl;

    cin >> s >> i;
    cout << "请输入的内容是：" << s << endl << i << endl;

4. 字符串类型 string（掌握）

4.1 基础使用

string并不是C++的基本数据类型，string是C++内置的字符串类，使用时需要引入头文件<string>，而不是<string.h>，string在绝大多数情况下可以代替char*，不必担心内存是否足够和字符串长度。

string使用ASCII编码，只支持英文字符，严禁使用中文字符！！！

string内部集成了大量的字符串处理函数。

string s = "yui%^";
    // 获取字符串长度
    cout << s.size() << " " << s.length() << endl; // 5 5

    cout << "--------for循环遍历--------" << endl;
    for(int i = 0;i<s.size();i++)
    {
        // 使用下标取出对应的字符
        cout << s[i] << " ";
    }

    cout << endl;
    // C++11支持
    cout << "--------for each循环遍历--------" << endl;
    for(char c:s)
    {
        cout << c << " ";
    }

4.2 取出元素

string不光支持中括号 [ ] 的方式取出元素，还支持使用at函数的方式取出元素。

这两种方式的区别是：

● 前者取出的效率更高

● 后者更加安全

 string s = "yui%^";

    // 使用中括号取出元素
    cout << s[1] << endl; // u

    // 使用at函数取出元素
    cout << s.at(1) << endl; // u

    // 范围越界
    cout << s[-999] << endl; // '\0'
    cout << s.at(20) << endl; // 运行终止

    cout << "主函数执行完毕" << endl;

前者会打印换行继续运行直到程序结束

后者会程序运行终止打印错误提示语句

5. 函数

5.1 内联函数 inline（掌握）

内联函数的目的是取代宏定义的函数，使用关键字inline放在函数定义（非声明）的前面，可以将函数制定为内联函数。

内联函数在编译时，会直接展开函数体到主函数中编译，因此可以提升程序的运行效率。一般将代码长度较小（5行以内，不能包含复杂的控制语句）且频繁使用的函数写为内联函数。

所有的成员函数默认为内联函数，无需手动使用inline修饰。

inline void test()
{
    cout << "aaa" << endl;
}

5.2 函数重载 overload（重点）

C++中允许使用同一个函数名臣定义多个函数，这就是函数重载。函数重载的前提是各个重载的函数之间参数（类型或个数）不同，与返回值类型无关。

void show()
{
    cout << "1" << endl;
}

void show(int a)
{
    cout << "2" << a << endl;
}

void show(double d)
{
    cout << "2.5" << d << endl;
}

void show(string s)
{
    cout << "3" << s << endl;
}

void show(string s1,string s2)
{
    cout << "4" << s1 << s2 << endl;
}

除了上述的普通函数支持重载外，成员函数和构造函数等也支持函数重载，但是析构函数不支持函数重载。

5.3 函数的参数默认值（缺省值）（掌握）

C++中允许给函数的参数设定默认值，在调用函数时，如果传入参数，则传入的参数会覆盖默认值；如果不传入参数，则使用默认值作为参数值。

参数的默认值只允许在声明和定义中出现一次。

#include <iostream>
using namespace std;
void func1(int a = 0); // 声明时制定参数默认值
void func2(int a);
void func1(int a)
{
    cout << a << endl;
}
void func2(int a = 1) // 定义时制定参数默认值
{
    cout << a << endl;
}

int main()
{
    func1(); // 0
    func1(666); // 666
    func2(); // 1
    func2(888); // 888
    return 0;
}

向右（后）原则：如果函数参数有多个，此时给某个参数设定了默认值后，其右边（后边）所有的参数都必须设定默认值。

C++允许给函数参数设置默认值，调用时如果传入参数，传入的参数会覆盖默认值

默认值在函数声明和函数定义处只能出现一次

默认参数是严格按照从左到右的顺序使用

只要有一个参数为默认值，右边的必须全都是默认值

#include <iostream>
using namespace std;
void method1(int a,int b=1,int c=2)
{
    cout << a << b << c << endl;
}
int main()
{
//    method1(); 错误
    method1(0); // 012
    method1(0,0); // 002
    return 0;
}

当函数的参数默认值与函数重载同时使用时，非常容易导致二义性问题（ambiguous），二义性问题指的是编译器无法做出两种情况的抉择。

尽量不要同时使用函数重载和默认值。

#include <iostream>

using namespace std;

void method(int a=0,int b=1,int c=2)
{
    cout << a << b << c << endl;
}

void method()
{
    cout << "aaa" << endl;
}

int main()
{
//    method(); 错误
    return 0;
}

5.4 哑元函数（熟悉）

如果一个函数的参数只有类型，没有名字，这个参数在函数体中无法使用，这样的参数被称为哑元，这样的函数被称为哑元函数。

#include <iostream>

using namespace std;

/**
 * @brief test 哑元函数
 */
void test(string)
{
    cout << "hahah" << endl;
}


int main()
{
    test("Tom"); // hahah

    return 0;
}

哑元函数的主要有以下用途：

● 区分重载函数，后面在运算符重载中使用。

● 保持函数的向前兼容性