初识C++(1)

初识C++

C++是在C语言的基础上添加了面向对象编程的特性，所以C++兼容C，但是，C语言中也有一些错误的地方，C++在这方面对C进行了优化。

一、C++对C语言的优化

1.例1

#include<stdio.h>

#include<stdlib.h>

int rand = 10;

int main()

{
    printf("%p\n", rand);

    return 0;

}

这样写的话，就会报错

编译报错：

C2365 “rand”:重定义；以前的定义是“函数”

那么为什么会出现这样的错误呢？？
因为在stdlib.h中包含C语言库中的函数rand，这属于C语言中的命名冲突情况，这是C语言中存在的一个问题：
在我们写一段程序时，一开始都是好的，可以运行成功，但是一旦要包含一个头文件时，就会报错，有可能是包含的头文件中有函数名和代码中定义的变量名产生命名冲突。
那么C++该如何解决这个问题？？
下面就引出了第一个C++的知识点：namespace

二、namespace

1.namespace的定义

1.定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。 2.namespace本质是定义一个域，这个域跟全局域各自独立，不同的域可以定义同名变量，同一个域不能定义同名变量。
3.C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找一个变量/函数/类型出处(声明或定义)的逻辑，所以有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量的生命周期。
4.namespace只能定义在全局，还可以嵌套定义。
5.项目工程中多文件中定义的同名namespace会认为是同一个namespace，不用担心会有冲突的情况。
6.C++标准库都放在一个叫std(standard)的命名空间中。

2.namespace定义函数

#include<stdio.h>
#include<stdlib.h>

namespace xingguang
{
    int Add(int a, int b)
    {
        return a + b;
    }    
}

int main()
{
    printf("%d\n", xingguang::Add(3, 2));
    return 0;
}

5

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 23904)已退出，代码为 0。
按任意键关闭此窗口. . .

3.namespace定义结构体

#include<stdio.h>
#include<stdlib.h>

namespace xingguang
{
    struct Node
    {
        struct Node* next;
        int data;
    };
}

int main()
{
    struct xingguang::Node node1;

    //注意顺序有所不同
    return 0;
}

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 22292)已退出，代码为 0。
按任意键关闭此窗口. . .

4.namespace嵌套定义

#include<stdio.h>
#include<stdlib.h>

namespace xingguang
{
    namespace zhangsan
    {
        int Add(int a, int b)
        {
            return a + b;
        }
        struct Node
        {
            struct Node* next;
            int data;
        };
    }
    namespace wangwu
    {
        int Add(int a, int b)
        {
            return a + b;
        }
        struct Node
        {
            struct Node* next;
            int data;
        };
    }    
}

int main()
{
        printf("%d\n", xingguang::zhangsan::Add(3, 2));
        struct xingguang::zhangsan::Node node1;
        printf("%d\n", xingguang::wangwu::Add(3, 4));
        struct xingguang::wangwu::Node node2;
        return 0;
}

5
7

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 18736)已退出，代码为 0。
按任意键关闭此窗口. . .

5.namespace的使用

编译查找一个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间里面去查找。所以我们要使用命名空间中定义的变量/函数，有三种方式：

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

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

#include<stdio.h>
#include<stdlib.h>

namespace xingguang
{
    int a = 1;
    int b = 2;
}

using xingguang::a; 
int main()
{
    printf("%d\n", a);    
    printf("%d\n", a);    
    printf("%d\n", a);    
    printf("%d\n", a);    
    printf("%d\n", a);    
    printf("%d\n", xingguang::b);    
    return 0;
}

1
1
1
1
1
2

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 5452)已退出，代码为 0。
按任意键关闭此窗口. . .

因为a常用，所以可以把a展开。
3.展开命名空间中全部成员，项目不推荐，冲突风险大，日常小练习程序为了方便，推荐使用。

#include<stdio.h>
#include<stdlib.h>

namespace xingguang
{
    int a = 1;
    int b = 2;
}

using namespace xingguang; 
int main()
{
    printf("%d\n", a);    
    printf("%d\n", a);    
    printf("%d\n", a);    
    printf("%d\n", a);    
    printf("%d\n", a);    
    printf("%d\n", b);    
    return 0;
}

1
1
1
1
1
2

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 20628)已退出，代码为 0。
按任意键关闭此窗口. . .

6.修改例1错误代码

#include<stdio.h>
#include<stdlib.h>

namespace xingguang
{
    int rand = 10;
}
int main()
{
    printf("%p\n", rand);
    return 0;
}

此时rand整型变量，被封在域中，这时rand访问的是stdlib.h中的函数rand，不会产生命名冲突的情况。

7.例2

#include<stdio.h>
#include<stdlib.h>

int a = 10;

int main()
{
    int a = 1;
    printf("%d\n", a);
    return 0;
}

1

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 23008)已退出，代码为 0。
按任意键关闭此窗口. . .

我们知道，访问变量采用的是就近原则，也就是说，如果在全局中定义一个变量，在局部域中也定义一个同名变量，那么就会优先访问局部变量。
那么我们该怎么做，可以实现访问全局变量？？
下面引出C++的第二个知识点：域作用限定符（::）

三、域作用限定符（::）

1.解决例2出现的问题

#include<stdio.h>
#include<stdlib.h>

int a = 10;

int main()
{
    int a = 1;
    printf("%d\n", a);
    printf("%d\n", ::a);
    return 0;
}

1
10

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 24256)已退出，代码为 0。
按任意键关闭此窗口. . .

在a前面加上域作用限定符，就会去全局中找变量a。

那么作为域作用限定符，我们可不可以用它来访问namespace中的变量呢？？
答案是可以的

2.例3

#include<stdio.h>
#include<stdlib.h>

namespace xingguang
{
    int rand = 10;
}

int main()

{
    printf("%p\n", rand);
    printf("%d\n", xingguang::rand);
    return 0;
}

00007FFE6C224AD0
10

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 20232)已退出，代码为 0。
按任意键关闭此窗口. . .

第一个访问的是stdlib.h中的函数rand，因为是函数，所以最好使用%p(函数指针)，第二个访问的是域中的rand，因为是整型变量，所以使用%d访问。

PS：域中的rand还是全局的，只不过受域的限制，必须有域作用限定符才能访问。

PS：命名空间域只能定义在全局，不能定义在局部。

四、C++的输入&输出

1.是Input Outout Stream的缩写，是标准的输入、输出流库，定义了标准的输入、输出对象。

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

3.std::cout是ostream类的对象，它主要面向窄字符的标准输出流。

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

5.<<是流插入运算符，>>是流提取运算符。

6.使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动定义格式，C++的输入输出可以自动识别变量类型(本质是通过函数重载实现的)，其实最重要的是C++的流能更好的支持自定义类型对象的输入输出。

#include<iostream>
using namespace std;

int main()
{
    int a = 10;
    cout<< a <<endl;    
    return 0;
}

10

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 23828)已退出，代码为 0。
按任意键关闭此窗口. . .

#include<iostream>

int main()
{
    int a = 10;
    std::cout<< a <<std::endl;    
    return 0;
}

10

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 23928)已退出，代码为 0。
按任意键关闭此窗口. . .

上述例子可以说明cout、cin和endl包含在iostream中的命名空间std中，如果不展开std，就需要std::cin和std::cout，如果展开就可以省略了。

#include<iostream>
using namespace std;

int main()
{
    int a = 10;
    int b = 5;
    printf("%d\n", b);
    cout<< a <<endl;    
    return 0;
}

5
10

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 23736)已退出，代码为 0。
按任意键关闭此窗口. . .

这里没有包含<stdio.h>，也可以使用printf和scanf，在包含间接包含了。vs系列编译器是这样的，其他编译器可能会报错。

2.扩展

//在io需求比较高的地方，如部分大量输入的竞赛题中，加上以下3行代码
//可以提高c++I/O效率
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);

五、缺省参数

1.缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。(有些地方把缺省参数也叫默认参数)。
2.全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。
3.带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。
4.函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。因为不如果声明和定义同时给不同的缺省值时，该以谁为准？？

#include<iostream>
using namespace std;

//全缺省
void Func1(int a  = 10, int b = 20, int c = 30)
{
    cout<< "a = "<< a << endl;
    cout<< "b = "<< b << endl;
    cout<< "c = "<< c << endl << endl;
}

//半缺省
void Func2(int a, int b = 20, int c = 30)
{
    cout<< "a = "<< a << endl;
    cout<< "b = "<< b << endl;
    cout<< "c = "<< c << endl << endl;
}    
int main()
{
    Func1();
    Func1(1);
    Func1(1, 2);
    Func1(1, 2, 3);         
    Func2(4);         
    return 0;
}

a = 10
b = 20
c = 30

a = 1
b = 20
c = 30

a = 1
b = 2
c = 30

a = 1
b = 2
c = 3

a = 4
b = 20
c = 30


C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 20064)已退出，代码为 0。
按任意键关闭此窗口. . .

注意：不能够跳跃式赋值

1.缺省参数适用实例：

在数据结构开辟动态栈时，在事先不清楚要开辟多大的时候，可以定义缺省值，明确需要多大的空间时，直接修改缺省值即可，这样可以避免连续开辟造成的时间和空间损失，提高效率。

六、函数重载

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

1.形参不同

#include<iostream>
using namespace std;

double Add(int a, double b)
{
    cout << a + b << endl;
    return a + b;
}
double Add(double a, int b)
{
    cout << a + b << endl;
    return a + b;
}
int main()
{
    Add(1, 2.2);
    Add(1.1, 2);
    return 0;
}

3.2
3.1

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 14384)已退出，代码为 0。
要在调试停止时自动关闭控制台，请启用“工具”->“选项”->“调试”->“调试停止时自动关闭控制台”。
按任意键关闭此窗口. . .

2.参数个数不同

#include<iostream>
using namespace std;

int Add(int a, int b)
{
    cout << a + b << endl;
    return a + b;
}
int Add(int a, int b, int c)
{
    cout << a + b + c << endl;
    return a + b + c;
}
int main()
{
    Add(1, 2, 3);
    Add(1, 2);
    return 0;
}

6
3

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 3804)已退出，代码为 0。
按任意键关闭此窗口. . .

3.类型不同

#include<iostream>
using namespace std;

int Add(int a, int b)
{
    cout << a + b << endl;
    return a + b;
}double Add(double a, double b)
{
    cout << a + b << endl;
    return a + b;
}
int main()
{
    Add(1.1, 2.2);
    Add(1, 2);
    return 0;
}

3.3
3

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 9888)已退出，代码为 0。
按任意键关闭此窗口. . .

4.易错点1

下面两个函数构成函数重载吗？？

void f1()
{
    cout << "f1()" << endl;
}
void f1(int a = 10)
{
    cout << "f1(int a)" << endl;

}

这两个函数构成重载，但是在调用f1()时，会报错，存在歧义，编译器不知道调用谁。

#include<iostream>
using namespace std;

void f1()
{
    cout << "f()" << endl;
}
void f1(int a = 10)
{
    cout << "f(int a)" << endl;

}
int main()
{
    f1();
    return 0;
}

E0308	有多个 重载函数 "f1" 实例与参数列表匹配
C2668	“f1”: 对重载函数的调用不明确

结合前面刚学过的知识，如何能够正常调用f1()时，不会产生歧义呢？？
当然是使用命名空间来解决了。

5.利用命名空间来解决4.易错点1

#include<iostream>
using namespace std;

namespace xingguang
{
    void f1()
    {
        cout << "f()" << endl;
    }
}
void f1(int a = 10)
{
    cout << "f(int a)" << endl;

}
int main()
{
    f1();
    return 0;
}

f(int a)

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 20352)已退出，代码为 0。
按任意键关闭此窗口. . .

用命名空间就可以解决调用f1()产生歧义的问题，但是需要注意的是：

1.易错点

此时这两个函数已经不是函数重载的关系了，因为函数重载的前提是在同一作用域之内，使用命名空间后，这两个函数就不在同一个作用域中了，所以就不是函数重载的关系了。

6.易错点2

返回值不同，不能构成函数重载！！
因为在调用时无法区分

七、引用

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

#include<iostream>
using namespace std;

int main()
{
    int a = 0;
    //引用：b和c是a的别名
    int& b = a;
    int& c = a;

    //也可以给别名b取别名，d相当于还是a的别名
    int& d = b;
    d++;//d++本质上就相当于a++
    cout << &a << endl;
    cout << &b << endl;
    cout << &c << endl;
    cout << &d << endl;
    cout << a << endl;
    return 0;
}

000000F532B9F684
000000F532B9F684
000000F532B9F684
000000F532B9F684
1

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 17132)已退出，代码为 0。
按任意键关闭此窗口. . .

1.引用可以代替指针

#include<iostream>
using namespace std;

void Swap(int& rx, int& ry)
{
    int tmp = rx;
    rx = ry;
    ry = tmp;
}
int main()
{
    int x = 1;
    int y = 2;
    cout << "x = " << x << "," << "y = " << y << endl;
    Swap(x, y);
    cout << "x = " << x << "," << "y = " << y << endl;
    return 0;
}

x = 1,y = 2
x = 2,y = 1

C:\Users\Lenovo\source\repos\初识C++\x64\Debug\初识C++.exe (进程 18768)已退出，代码为 0。
按任意键关闭此窗口. . .

2.引用注意事项

1.引用在定义时必须初始化
2.一个变量可以有多个引用
3.引用一旦引用一个实体，再不能引用其他实体
4.C++引用不能完全代替指针

3.引用的一些使用

1.引用在实践中主要是用于引用传参和引用做返回值中减少拷贝，提高效率和改变对象时同时改变被引用对象。
2.引用传参跟指针传参功能是类似的，引用传参相对更方便一些。
3.引用返回值的场景相对比较复杂。
4.引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的运用跟其他语言的引用(如Java)是有很大区别的，除了用法，最大的点，C++引用定义后不能改变指向，Java的引用可以改变指向。

4.const引用

1.可以引用一个const对象，但是必须用const引用。const引用也可以引用普通对象，因为对象访问权限在引用过程中可以缩小，但是不能放大。
2.需要注意的是类似int& rb = a * 3; double d = 12.34; int& rd = d;这样一些场景下a*3的和结果保存在一个临时对象中，int& rd = d也是类似，在类型转换中会产生临时对象存储中间值，也就是，rb和rd引用的都是临时对象，而C++规定临时对象具有常性，是只能读不能写的，所以这里就触发了权限放大，必须要用const引用才可以。
3.所谓临时对象就是编译器需要一个空间暂存表达式的求值结果时临时创建的一个未命名的对象，C++中把这个未命名对象叫做临时对象。
4.const引用可以常量取别名，普通的引用不可以。

#include<iostream>
using namespace std;


int main()
{
    const int a = 1;
    //int& b = a;错误，权限放大
    const int& b = a;//引用
    int c = a;//不是引用，而只是单纯的拷贝
    
    //权限缩小
    int c = 2;
    const int& d = c;
    return 0;
}

注意c和d的区别：
c可读可写，d只读不写，虽然d是c的引用，但是没有改变c的权限

#include<iostream>
using namespace std;


int main()
{
    const int a = 1;
    int b = 2;
    const int& rc = 30;
    //int& rb = (a + b);错误，权限放大
    const int& rb = (a + b);
    //表达式a+b的结果会保存到一个临时对象中，rb引用的是这个临时对象，因为前面提到的临时对象具有常性，所以要用const引用才可以

    double d = 12.34;
    int i = d;
    //int& ri = d;错误,
    const int& ri = d;
    //这里存在隐式类型转换，C++规定，产生隐式类型转换时，也会产生临时对象，因为ri引用的是这个临时对象，所以要用const引用，
    return 0;
}

1.const引用的价值

1.const引用临时对象的时候，临时对象的生命周期会跟引用保持一致，只有引用的销毁，临时变量才会销毁。
2.const引用作为函数传参时，非常方便，因为可以传常量，表达式，变量，这样没有限制，传参的范围很宽泛。

八、指针和引用的关系

C++中指针和引用就像两个性格迥异的亲兄弟，指针是哥哥，引用是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有自己的特点，互相不可替代。
1.语法概念上引用是一个变量的取别名不开空间，指针是存储一个变量地址，要开空间。
2.引用在初始化时引用一个对象后，就不能再引用其他对象；而指针可以不断地改变指向对象。
3.引用在定义时必须初始化，指针建议初始化，但是在语法上不是必须的。
4.引用可以直接访问指向对象，指针需要解引用才是访问指向对象。
5.sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位下是8byte)。
6.指针很容易出现空指针和野指针问题，引用很少出现，引用使用起来相对安全一些。

九、inline

1.用inline修饰的函数叫做内联函数，编译时C++编译器会在调用的地方展开内联函数，这样调用内联函数就需要建立栈帧了，就可以提高效率。
2.inline对于编译器而言只是一个建议，也就是说，你加了inline编译器也可以在调用的地方不展开，不同的编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。inline适用于频繁调用的短小函数，对于递归函数，代码相对多一些的函数，加上inline也会被编译器忽略。
3.C语言实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不方便调试，C++设计了inline目的就是替代C的宏函数。

1.实现一个宏，常见的错误

//常见错误
//#define ADD(int a, int b) return a + b;
//#define ADD(a, b) a + b;
//#define ADD(a, b) (a + b)

//正确的宏实现
#define ADD(a, b) ((a) + (b))
//为什么不能加分号？？
//为什么要加外面的括号？？
//为什么要加里面的括号？？

2.解释问什么会产生这些错误

#include<iostream>
using namespace std;

#define ADD(a, b) ((a) + (b))
int main()
{
    int ret = ADD(1, 2);//int  ret = ((1) + (2));
    //解释1：为什么不能加分号
    //cout << ADD(1, 2) << endl;
    //加分号，就会报错了
    //解释2：为什么要加外面的括号
    cout << ADD(1, 2) * 5 << endl;
    //不加外面的括号，由于运算的符的优先级，就会导致最后的运算结果和正确的结果产生偏差
    //解释1：为什么要加里面的括号
    //因为a和b有可能是表达式，不加括号的话，由于优先级的关系，有可能也会出错
    // int x = 1; int y = 2;
    // ADD(x & y, x | y);
    // 不加括号：ADD(x & y + x | y)
    // 加括号：ADD((x & y) + (x | y))
    return 0;
}

3.用inline可以简化宏函数，避免这些错误

#include<iostream>
using namespace std;

inline int Add(int a, int b)
{
    int ret = a + b;
    return ret;
}
int main()
{
    int ret = Add(1, 2);
    cout << Add(1, 2) * 5 << endl;
    cout << ret << endl; 
    return 0;
}

inline int Add(int a, int b)
{
    int ret = a + b;
    return ret;
}
int main()
{
    int ret = Add(1, 2);
    cout << Add(1, 2) * 5 << endl;
    cout << ret << endl;
    return 0;
}

4.VS编译器debug版本下面默认是不展开inline的，这样方便调试。
5.inline不建议声明和定义分离到两个文件，分离会导致链接错误。因为inline被展开，就没有函数地址，链接时就会出现报错。

十、nullptr

NULL实际上是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifdef NULL
    #ifdef __ cplusplus
        #define NULL    0
    #else
        #define NULL    ((void *)0)
    #endif
#endif      

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