C++入门基础

C++的第一个程序：

#include<iostream>
using namespace std;
int main()
{
    cout << "hello zyb" << endl;
    return 0;
}

1.命名空间

1.1前情提要

   在C语言中，我们知道在同一个域中，我们是不能定义两个同名的变量的，否则，会引起冲突的，但是，在我们的生活中，在公司上班时，会将几个人写的代码合并成一个代码时，难免会出现这种情况，如下所示：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int rand = 1;
int main()
{
    printf("%d\n", rand);
    return 0;
}

通过上副图的报错信息可知，rand函数重定义了，因为头文件#include<stdlib.h>中也定义了一个叫rand的函数，与我们定义的整数rand名字重了，很麻烦，为了避免这种情况，在C++中引入了命名空间这个概念，就有了了一个关键字namespace。

1.2namespace的定义

   （1）.定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{ }即可，{ }中即为命名空间的成员，命名空间中可以定义变量/函数/类型等，例。

namespace zyb//zyb是这个命名空间的名字
{
    int rand = 10;//命名空间中的成员
}

   （2）.namespace本质上是定义一个域，这个域跟全局域各自独立，不同的域可以定义同名变量，因此，这样就可以有效的避免上面遇到的冲突的这种情况，例。

namespace zyb
{
    int rand = 10;
}
namespace zyx
{
    int rand = 10;
}

   （3）.C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找一个变量\函数\类型出处（声明或定义）的逻辑，所以有了隔离域，名字冲突这个问题就解决了，局部域和全局域，除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不会影响变量的生命周期。

   补（1）：这里我们再补充一个知识点，当我们同时定义了两个变量a时，这两个变量一个是全局变量，一个是局部变量，最后在输出时是访问最近的那个变量a，叫做就近原则，先在局部找，再在全局找，如下图所示。

当我们到一个全局域去找某一个变量的时候，我们用到一个域作用限定符"::"

这样，我们就可以去访问到命名空间中的信息了。

#include<stdio.h>
namespace zyb
{
    int rand = 101;
    struct node
    {
        int i = 10;
    };
}
int main()
{
    printf("%d", zyb::rand);
    struct zyb::node p1;//zyb要写在node的前面，因为struct只是一个关键字，node才是结构体的名字。
    return 0;
}

   （4）.namespace只能定义在全局，它还可以嵌套定义：

#include<stdio.h>
namespace zjhy
{
    namespace zyb
    {
        int a = 19;
    }
    namespace zyx
    {
        int a = 29;
    }
    //...
}
int main()
{
    printf("%d\n", zjhy::zyb::a);// 19
    printf("%d\n", zjhy::zyx::a);// 29
    return 0;
}

   （5）.项目工程中多文件定义的同名namespace会认为是一个namespace，不会起冲突。

由上图我们可知，stack.cpp文件和stack.h文件全部都使用同一个名字的命名空间分装起来，但我们在进行链接过程的时候，系统会认为这两个同名的命名空间是同一个命名空间，可以正常运行。

1.3命名空间的使用

   （1）.指定命名空间访问，项目中推荐这种方式。

   （2）.using将命名空间中的某个成员展开，项目中经常访问的并且不存在冲突的推荐使用这种方式。

#include<stdio.h>
namespace zyb
{
    int a = 10;
}
using namespace zyb;
int main()
{
    printf("%d\n", a);//10
    return 0;
}

   （3）.展开命名空间中的全部成员，项目中不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。当然，我们也可以展开常用的。

#include<stdio.h>
namespace zyb
{
    int a = 10;
    int b = 20;
}
using zyb::b;
int main()
{
    printf("%d\n", zyb::a);//10
    printf("%d\n", b);//20
    return 0;
}

2.C++的输入&输出

   （1）.<iostream>是Input Output Stream的缩写，是标准的输入输出流库，定义了标准的输入输出对象。

   （2）.std::cin是istream类的对象，他主要是面向窄字符的标准输入流。

   （3）.std::out是ostream类的对象，他主要是面向窄字符的标准输出流（std::的意思是cin和cout都是在输入输出流库中的一个叫作std的命名空间中，若想使用cin和cout的话，就必须使用std::到std这个命名空间中去中找cin和cout）。

就像printf()输出函数，它在输出一个整数时，是将这个整数转化成字符输出来的，例如：

printf（"%d\n",1234);//1234

就是将1234这个整数转化成4个字符输到屏幕中去，这里也是这个道理。

   （4）.<<是流插入运算符，>>是流提取运算符，这些都是。（C语言还用这两个运算符做位移运算符左移/右移，C++中这两个运算符是作为输入和输出）

   （5）.std::endl是一个函数，流插入输出时，相当于插入一个换行字符加刷新缓冲区。

#include<iostream>
using namespace std;
int main()
{
    int a = 0;
    int b = 0;
    cin >> a >> b;//输入随机地两个int类型的值。
    cout << b << " " << a << endl;//输出两个值。
    return 0;
}

   （6）.使用C++输入输出会变得很方便，不需要像printf/scanf输入输出时的那样，需要手动指定格式，C++的输入输出可以自动识别变量类型，其实最重要的是C++的流能更好地支持自定义类型对象地输入和输出。

#include<iostream>
using namespace std;
int main()
{
    int a = 10;
    double b = 2.1;
    cout << a << " " << b << endl;
    int c = 0;
    double d = 0;
    cin >> c >> d;
    cout << c << " " << d << endl;
    return 0;
}

我们在输出d的时候，只输出了小数点最后5位，是因为C++默认输出小数点为5位（这里再来提醒一下大家，就是如果想要控制小数点的精度，建议使用C语言的那一套来控制，C++过于麻烦）。

3.缺省参数

   （1）.缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用函数时，如果没有传参，则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数（有些地方把缺省参数也叫做默认参数）。

#include<iostream>
using namespace std;
void func(int a = 2)//2就是一个缺省值
{
    cout << a << endl;
}
int main()
{
    func();//2,没有传参时，使用函数的默认值，也就是缺省值（此处指的是缺省值2）
    func(5);//5,有参数时，使用参数（这里的参数是5）
    return 0;
}

   （2）.全缺省参数就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右到左必须依次连续缺省，不能间隔跳跃给缺省值。

// 全缺省
void Func1(int a = 10, int b = 20, int c = 30);
// 半缺省
void Func2(int a, int b = 20, int c = 30);
void Func3(int a = 10, int b, int c = 30);//编译器会报错，因为这里间隔跳跃给参省值
void Func4(int a = 10, int b = 20, int c);//编译器会报错，因为这里没有从右往左依次参省

   （3）.带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。

#include<iostream>
using namespace std;
void Func(int a = 10, int b = 20, int c = 30)
{
    cout << a << " " << b << " " << c << endl;
}
int main()
{
    Func(5);//5 20 30
    Func(5, 10);//5 10 30
    Func(5, 10, 15);//5 10 15
    return 0;
}

   （4）.函数的声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值（函数的定义中不能给缺省值）。

#include<iostream>
using namespace std;
void func(int a = 10, int b = 20, int c = 30);
int main()
{
    func();
    return 0;
}
void func(int a, int b, int c)
{
    cout << a << " " << b << " " << c << endl;
}

4.函数重载

   C++支持在同一作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数不同或者类型不同。这样C++函数调用就表现出了多态行为，使用的更加灵活。C语言是不支持同一作用域中出现同名函数的。

// 1.参数类型不同
void Add(int left, int right)
{
    cout << "Add(int left, int right)" << endl;
}
void Add(double left, double right)
{
    cout << "Add(double left, double right)" << endl;
}
// 2.参数个数不同
void f()
{
    cout << "f()" << endl;
}
void f(int a)
{
    cout << "f(int a)" << endl;
}
// 3.参数类型顺序不同
void func(int a, double b)
{
    cout << "func(int a, double b)" << endl;
}
void func(double b, int a)
{
    cout << "func(double b, int a)" << endl;
}

5.引用

4.1引用的概念

   引用不是新定义⼀个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同⼀块内存空间。

   类型&  引用名=引用对象

#include<iostream>
using namespace std;
int main()
{
    int a = 10;
    int& b = a;//引用，b是a的别名（就是另一个名字）
    //类型&  引用名=引用对象
    b = 20;
    cout << b << " " << a << endl;//20 20
    cout << &b << " " << &a << endl;//输出来的两个地址都一样
    return 0;
}

4.2引用的特征

   （1）.引用必须初始化。

#include<iostream>
using namespace std;
int main()
{
    int a = 10;
    int& b = a;
    b = 20;
    cout << b << " " << a << endl;
    cout << &b << " " << &a << endl;
    return 0;
}

    （2）.一个变量可以有多个引用。

#include<iostream>
using namespace std;
int main()
{
    int a = 10;
    int& b = a;
    int& c = a;
    int& d = a;
    b = 20;
    cout << b << " " << a << endl;
    cout << &b << " " << &a << endl;
    return 0;
}

   （3）.引用一旦引用一个实体，就不可以再引用其他实体。

4.3引用的使用

   （1）.引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被引用对象。

   （2）.引用传参跟指针传参功能是类似的，引用传参相对更⽅便⼀些。

   （3）.引用返回值的场景相对比较复杂，我们在这⾥简单讲了⼀下场景，还有⼀些内容后续类和对象章节中会继续深入讲解。

   （4）.引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引⽤跟其他语言的引用(如Java)是有很大的区别的，除了用法，最大的点，C++引用定义后不能改变指向，Java的引用可以改变指向。

   （5）.⼀些主要用C代码实现版本数据结构教材中，使用C++引用替代指针传参，目的是简化程序，避开复杂的指针，但是很多同学没学过引用，导致⼀头雾水。

4.4const引用

   （1）.可以引用一个const对象，但是必须是const引用。const引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但是不能放大。

#include<iostream>
using namespace std;
int main()
{
    int a = 10;//a的访问权限是既可以读取，也可以修改
    int& b = a;//b的访问权限是既可以读取，也可以修改
    //引用权限不能放大，只能是权限相同或权限缩小
    const int a1 = a;//a1被const修饰，访问权限只是读取a，没有修改它，属于权限缩小
    const int& a2 = a;//a2被const修饰，访问权限只是读取，没有修改它，属于权限缩小
    const int c = 20;//c被const修饰，访问权限只能读取，不能修改
    const int& d = c;//d被const修饰，访问权限只能读取，不能修改，属于权限相同
    return 0;
}

c1是既可以读取，也可以修改，而c只能读取，不能修改，上面的那张图片中的第12行的那句代码的问题是属于权限放大的问题。（也就是说，赋给c1的那个值也必须是既可以读取，也可以修改）

   （2）.这里我们再来说一个有关临时对象的概念，所谓的临时对象就是编译器需要一个空间暂时存放表达式求值结果时临时创建的一个未命名的对象，C++中把这个未命名对象叫做临时对象。

   （3）.不需要注意的是类似 int& rb = a*3; double d = 12.34; int& rd = d; 这样⼀些场景下a*3的和结果保存在⼀个临时对象中， int& rd = d 也是类似，在类型转换中会产⽣临时对象存储中间值，也就是时，rb和rd引⽤的都是临时对象，⽽C++规定临时对象具有常性（换句话说，就是被const修饰的），所以这⾥就触发了权限放⼤，必须要⽤常引⽤（const修饰）才可以。

(a+b)是一个表达式，它的结果会被存放在临时对象中，这个临时对象没有名字并且具有常性，只能读取，不能修改，此时若用int类型去引用的话，会将权限放大，从而出错，因此，必须用const修饰。（类型转换也是如此）

using namespace std;
int main()
{
    int a = 10;
    int b = 20;
    const int& c = (a + b);
    double d = 2.34;
    const int& e = d;
    cout << c << " " << e << endl;//30 2
    return 0;
}

4.5指针与引用的关系

   C++中指针和引⽤就像两个性格迥异的亲兄弟，指针是哥哥，引⽤是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有⾃⼰的特点，互相不可替代。

   （1）.语法概念上引⽤是⼀个变量的取别名不开空间，指针是存储⼀个变量地址，要开空间。
    （2）.引⽤在定义时必须初始化，指针建议初始化，但是语法上不是必须的。
    （3）.引⽤在初始化时引⽤⼀个对象后，就不能再引⽤其他对象；⽽指针可以在不断地改变指向对象。
    （4）.引⽤可以直接访问指向对象，指针需要解引⽤才是访问指向对象。
    （5）.sizeof中含义不同，引⽤结果为引⽤类型的⼤⼩，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位下是8byte)
    （6）.指针很容易出现空指针和野指针的问题，引⽤很少出现，引⽤使⽤起来相对更安全⼀些。

6.inline

#include<iostream>
using namespace std;
inline int Add(int x, int y)
{
    int a = x + y;
    return a;
}
int main()
{
    int c = Add(3, 5);//8
    return 0;
}

   （1）.⽤inline修饰的函数叫做内联函数，编译时C++编译器会在调⽤的地⽅展开内联函数，这样调⽤内联函数就需要建⽴栈帧了，就可以提⾼效率。
    （2）.inline对于编译器⽽⾔只是⼀个建议，也就是说，你加了inline编译器也可以选择在调⽤的地⽅不展开，不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。inline适⽤于频繁调⽤的短⼩函数，对于递归函数，代码相对多⼀些的函数，加上inline也会被编译器忽略。

   （3）.C语⾔实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不⽅便调试，C++设计了inline⽬的就是替代C的宏函数。
    （4）.inline不建议声明和定义分离到两个⽂件，分离会导致链接错误。因为inline被展开，就没有函数地址，链接时会出现报错。

7.nullptr

NULL实际上就是一个宏，代码如下所示：

#ifndef NULL
    #ifdef __cplusplus//如果是在C++中，NULL代表的是0
        #define NULL 0
    #else//如果不是在C++中，NULL代表的是无类型的指针
        #define NULL ((void *)0)
    #endif
#endif

   （1）.C++中NULL可能被定义为字⾯常量0，或者C中被定义为⽆类型指针(void*)的常量。不论采取何种定义，在使⽤空值的指针时，都不可避免的会遇到⼀些⿇烦，本想通过f(NULL)调⽤指针版本的f(int*)函数，但是由于NULL被定义成0，调⽤了f(int x)，因此与程序的初衷相悖。f((void*)NULL);调⽤会报错。
    （2）.C++11中引⼊nullptr，nullptr是⼀个特殊的关键字，nullptr是⼀种特殊类型的字⾯量，它可以转换成任意其他类型的指针类型。使⽤nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被隐式地转换为指针类型，⽽不能被转换为整数类型。

   OK，谢谢大家的观看，感谢大家的支持！