C++入门知识

C++第一个程序

C++兼容C语言绝大多数的语法，如C语言中的输入（scanf），输出（printf）均可使用。对于C++程序而言需要将文件的后缀名命名为.cpp。VS编译器对于以.cpp后缀名结尾的文件将会调用C++编译器编译，linux环境下要使用g++指令进行编译。

以下代码使用C++中的cout来打印hello world

#include<iostream>
using namespace std;//展开std命名空间

int main()
{
    cout << "hello world" << endl;
    return 0;
}

命名空间

在C++中，变量，函数以及后面的类可能会大量存在同一文件或不同的文件中，如果不将这些用作用域将其隔离起来可能会导致冲突，所以C++相比较C语言，C++使用命名空间来对这些命名冲突进行隔离，避免命名冲突或名字污染等问题。命名空间的关键字是namespace
如果不用namespace命名空间进行隔离，可能会出现冲突。

例如，有代码如下所示：

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

上述代码会出现：error C2365: “rand”: 重定义；，这是由于rand这个名字在stdlib.h头文件中是一个函数，而rand又被定义成一个变量所以就造成了重定义。

定义命名空间

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

namespace的使用形式如下

namespace xyz
{
	//可在此定义函数，变量，类型等
}

namespace本质是定义出⼀个域，这个域跟全局域各自独立，不同的域可以定义同名变量。

将上述的rand的定义成如下，就不会造成冲突了

namespace xyz
{
	int rand=10;
}

C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找⼀个变量/函数/类型出处(声明或定义)的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的声明周期，命名空间域和类域不影响变量生命周期。namespace只能定义在全局，并且namespace可以进行嵌套定义。

namespace嵌套定义

namespace xyz
{
	int x=10;
	namespace abc
	{
		int x=10;//不与xyz命名空间中的x冲突，这个x是xyz域中的abc域中的x
	}
}

需要注意的是，如果在不同文件下定义同名的namespace，这会被认为是一个namespace，编译器将会将其归并在一个namespace中。
C++标准库都放在⼀个叫std(standard)的命名空间中。

命名空间的使用

编译查找⼀个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间里面去查找。

::称为作用域解析运算符，可以用这个来命名空间中的成员，也可访问类域。

如果要使用命名空间中的变量/函数/类型等，有三种方式：
①指定命名空间中的某个成员的访问，这种方式在项目中也推荐。用这种方式，每次使用命名空间下的成员都需要进行指定。

如，使用std空间下的cout：

std::cout
//后续如果要继续使用std空间中的cout，需要std::cout来访问cout

示例如下：

#include<iostream>
int main()
{
	std::cout<<"hello world"<<endl;
	//每次使用都要std::cout来指定
	std::cout<<"hello xyz"<<endl;
	return 0;
}

②using将命名空间中某个成员展开，经常访问的并且不存在冲突的成员推荐这种方式。这种方式展开的成员可直接使用不需要进行指定了

如果经常使用std空间下的cout，可使用以下方式展开:

using std::cout;//展开std空间下的cout
//展开之后，可后续不需要指定便可直接使用std空间下的cout

示例：

#include<iostream>
using std::cout;
int main()
{
	//直接使用std空间下的cout
	cout<<"hello world"<<endl;
	cout<<"hello xyz"<<endl;
	return 0;
}

③展开命名空间中所有的成员，项目中不推荐使用这种方式，日常使用可以这样展开方便使用。用这种方式后续该命名空间下的所有成员不需要指定便可直接使用。

如，将std中的成员都展开：

//展开std所有成员
using namespace std;

示例

#include<iostream>
using namespace std;//将std空间下的成员都展开了，std空间的成员均能直接使用，如cout,cin等
int main()
{
    //直接使用cout
    cout << "hello world" << endl;
    cout << "hello xyz" << endl;
    return 0;
}

C++输入输出

回顾一下C++中的第一个程序如下：

#include<iostream>
using namespace std;//展开std命名空间
int main()
{
    cout << "hello world" << endl;
    return 0;
}

① 是 Input Output Stream 的缩写，是标准的输入、输出流库，定义了标准的输入、输出对象。
②std::cin是istream 类的对象，它主要面向窄字符（narrow characters (of type char)）的标准输入流。
③std::cout是ostream类的对象，它主要面向窄字符的标准输出流。
④std::endl 是⼀个函数，流插⼊输出时，相当于插入⼀个换行字符，自动刷新缓冲区。
⑤<<是流插入运算符，>>是流提取运算符。（C语言用这两个运算符做位运算左移/右移）
⑥使用C++输入输出（cout，cin）更方便，不需要像printf/scanf输入输出时那样，需要手动指定格式，C++的输入输出可以自动识别变量类型（本质上是通过函数重载），C++的流能更好的支持自定义类型对象的输入输出（可以在通过函数重载来实现）。
⑦cout/cin/endl等都属于C++标准库，C++标准库都放在⼀个叫std(standard)的命名空间中，所以要通过命名空间的访问形式来进行访问。
⑧在日常的练习中可以使用using namespace std将std中的空间展开以便使用，但在实际项目中不建议这样使用，因为将其全部展开可能会造成命名冲突（在实际项目中更推荐的是std::cout这种形式）。
⑨iostream包含了许多输入/输出流相关的类和函数，如std::cin、std::cout、std::endl等。其中，std是C++标准库的命名空间，它包含了许多常用的类和函数，如std::string、std::vector、std::sort等。在VS编译器或linux中的g++编译器没有包含stdio.h头文件也可使用scanf和printf

缺省参数

缺省参数是声明或定义函数时为函数的参数指定⼀个缺省值。在调用该函数时，如果没有指定实参则采⽤该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（缺省参数也可称为默认参数）
全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。

全缺省参数示例：

#include<iostream>
using namespace std;

//全缺省
void func1(int a = 1, int b = 2, int c = 3)
{
    cout << a << endl;
    cout << b << endl;
    cout << c << endl;
}

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

半缺省示例：

//半缺省
void func2(int a, int b = 2, int c = 3)
{
    cout << a << endl;
    cout << b << endl;
    cout << c << endl;
}

int main()
{
    func2(1);//必须要传一个参数
    cout << endl;
    func2(1, 2);
    cout << endl;
    func2(1, 2, 3);
    cout << endl;
    return 0;
}

如果函数的定义声明分离，需要在声明处给缺省参数，定义处不给缺省参数。声明放在.h的头文件中，定义放在.cpp中。

示例：

//test.h文件下代码
#include<iostream>
//声明func3函数并给相应的缺省参数
void func3(int a = 1, int b = 2, int c = 3);

//test.cpp文件下代码
#include"test.h"
using namespace std;
void func3(int a, int b, int c)
{
    cout << a << endl;
    cout << b << endl;
    cout << c << endl;
}
int main()
{
    func3();//全缺省
    return 0;
}

函数重载

C++支持在同⼀作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同或参数类型顺序不同。这样C++函数调用就表现出了多态行为，使用更灵活。C语言是不支持同⼀作用域中出现同名函数的。
注意：在不同的命名空间中，当函数名相同，其参数个数不同或参数类型不同或参数类型的顺序不同，这不构成函数重载，函数重载指的是在同一作用域下。
根据传的参数（如参数的个数，参数的类型，参数类型顺序）调用相对应的函数

示例：函数形参的类型不同，构成函数重载

#include<iostream>
using namespace std;
int Add(int a, int b)
{
    return a + b;
}

double Add(double a, double b)
{
    return a + b;
}

int main()
{
    int x = 1;
    int y = 2;
    double m = 1.4;
    double n = 1.5;
    int ret1=Add(x, y);
    double ret2 = Add(m, n);
    cout << ret1 << endl;
    cout << ret2 << endl;
    return 0;
}

示例：函数的个数不同，构成函数重载

#include<iostream>
using namespace std;
void func()
{
    cout << "func()" << endl;
}
void func(int a)
{
    cout << "func(int)" << endl;
}
void func(int a, int b)
{
    cout << "func(int, int)" << endl;
}
int main()
{
    func();//调用无参的func
    func(1);//调用一个参数的func
    func(1,2);//调用2个参数func
    return 0;
}

示例：参数类型的顺序不同

void func(int a,double b)
{
    cout << "func(int, double)" << endl;
}
void func(double a, int b)
{
    cout << "func(double, int)" << endl;
}
int main()
{
    func(1, 6.6);
    func(6.6, 1);
    return 0;
}

需要注意，以下两个函数构成重载，但调用时存在歧义没编译器不知道调用哪个函数

#include<iostream>
using namespace std;
void func()
{
    cout << "func()" << endl;
}
void func(int a = 1)
{
    cout << "func(int)" << endl;
}
int main()
{
    func();//存在歧义编译器不知道调用哪个函数
    return 0;
}

引用

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

类型& 引用别名 = 引用对象

//示例
int a = 10;
int& b = a;//引用变量a，给变量a区别名b

测试a与b的地址：

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

可以看出a,b都是同一块空间，也就是b是a的别名。
需要注意：
①引用在定义时必须初始化
②应该变量可以有多个引用
③引用一旦引用一个实体，就不能用再去引用其他实体
④引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被引用对象
⑤引用传参跟指针传参功能是类似的，引用传参相对更方便⼀些。如果函数的形参使用引用，函数的实参直接传变量，形参通过引用接收这个参数。
⑥引用的返回，如果当前函数的栈帧销毁之后所返回的这个变量空间还存在那就可以使用引用返回，如果不存在了就不能用引用返回，只能用值拷贝返回。
⑦引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引用跟其他语言的引用(如Java)是有很⼤的区别的，除了⽤法，最大的点，C++引用定义后不能改变指向，Java的引用是可以改变指向

const引用

用const引用const对象。const引用也可以引用普通对象（这相当于权限的缩小），因为对象的访问权限在引用过程中可以平移，也可以缩小，但是不能放大。
不需要注意的是类似 int& rb = a3; double d = 12.34; int& rd = d; 这样⼀些场景下a3的和结果保存在⼀个临时对象中， int& rd = d 也是类似，在类型转换中会产⽣临时对象存储中间值，也就是时，rb和rd引⽤的都是临时对象，而C++规定临时对象具有常性，所以这里就触发了权限放大，必须要用const引用才可以。临时对象就是编译器需要⼀个空间暂存表达式的求值结果时临时创建的⼀个未命名的对象，C++中把这个未命名对象叫做临时对象。const 对临时对象进行引用会延长该临时对象的生命周期。

//示例
int a=10;
int& b=a;//correct,引用a,b就是a的别名,权限平移
const int& c=a;//correct,引用a，将权限缩小了，用a这个变量依然可以改变,c就不能改变了
double d=6.6;
int& e=d;//error，因为类型转换会产生中间的临时变量将d的值给临时变量，e引用的这个中间的临时变量，临时变量具有常性，必须使用const
const int& f=d;//correct，引用中间的那个临时变量
double& g=d;//correct，引用d,g就是d的别名,权限平移
const double& h=d;//correct,h的权限缩小

引用和指针的关系

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

inline函数

用inline修饰的函数叫做内联函数，编译时C++编译器会在调用的地方展开内联函数，这样调用内联函数就不需要建立栈帧了，就可以提高效率。需要注意的是：inline对于编译器而言只是⼀个建议，加了inline编译器也可以选择在调用的地方不展开，不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。inline适用于频繁调用的短小函数，对于递归函数，代码相对多⼀些的函数，加上inline也会被编译器忽略。C语言实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不方便调试，C++设计了inline目的就是替代C的宏函数。inline不能声明和定义分离到两个文件，分离会导致链接错误。因为inline被展开，就没有函数地址，链接时会出现报错。在C++中，类中的成员函数（如果类中的成员函数声明和定义没有分离，默认该函数前加了inline，虽说默认加了inline但是不一定会展开）

vs编译器 debug版本下面默认是不展开inline的，这样方便调试，debug版本想展开需要设置⼀下以下两个地方：

示例

#include<iostream>
using namespace std;

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

通过反汇编可以看到在调用的时候将其展开了

nullptr空指针

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

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

#include<iostream>
using namespace std;
void f(int x)
{
    cout << "f(int x)" << endl;
}
void f(int* ptr)
{
    cout << "f(int* ptr)" << endl;
}
int main()
{
    f(0);
    // 本想通过f(NULL)调⽤指针版本的f(int*)函数
    //但是由于在C++中NULL被定义成0，调⽤了f(int x)，因此与程序的初衷相悖。
    f(NULL);
    f((int*)NULL);
    // 编译报错：error C2665: “f”: 2 个重载中没有⼀个可以转换所有参数类型
    // f((void*)NULL);
    f(nullptr);
    return 0;
}

总结：本文主要介绍了C++的一些入门知识，如C++中的命名空间，简单的介绍了输入输出，缺省参数，函数重载，引用，inline内联函数，和nullptr空指针。如有错误之处，欢迎大家批评指正，感谢大家观看！！！