C++入门基础

命名空间

命名空间的定义

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

命名冲突

#include <stdio.h>
#include <stdlib.h>
int rand = 10;int main()
{//编译报错：“rand”重定义，以前的定义是“函数”printf("%d\n", rand);return 0;
}

在这里插入图片描述
rand已经在头文件stdlib.h中定义过了。

#include <stdio.h>
#include <stdlib.h>namespace bit
{int rand = 10;int Add(int x, int y){return x + y;}struct Node{int val;struct Node* next;};
}int x = 0;//没有指定域，先局部找再全局找
//指定域，直接去这个域找int main()
{int x = 1;printf("%d\n", x);//打印局部域中的x//::域作用限定符printf("%d\n", ::x);//打印全局域中的xprintf("%p\n", rand);//打印全局域中的stdlib.h头文件中rand函数的地址printf("%d\n", bit::rand);//打印命名空间域bit中的randreturn 0;
}

在这里插入图片描述

命名空间的嵌套定义

#include <stdio.h>namespace bit
{namespace bit1{int rand = 10;int Add(int x, int y){return x + y;}}namespace bit2{int rand = 20;int Add(int x, int y){return (x + y) * 5;}}
}int main()
{printf("%d\n", bit::bit1::rand);printf("%d\n", bit::bit2::rand);printf("%d\n", bit::bit1::Add(1, 2));printf("%d\n", bit::bit2::Add(1, 2));return 0;
}

在这里插入图片描述

命名空间的使用

指定命名空间访问，项目中推荐这种方式。
using将命名空间中某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式。
展开命名空间中全部成员，项目不推荐，冲突风险大，日常小练习程序为了方便推荐使用。

#include <stdio.h>namespace bit
{int a = 10;int b = 20;
}

//1 指定命名空间访问
int main()
{printf("%d\n", bit::a);printf("%d\n", bit::b);return 0;
}

//2 using将命名空间中某个成员展开
using bit::b;
int main()
{printf("%d\n", bit::a);printf("%d\n", b);
}

//3 展开命名空间中全部成员
using namespace bit;
int main()
{printf("%d\n", a);printf("%d\n", b);
}

C++输入/输出

iostream是Input Output Stream的缩写，是标准的输⼊/输出流库，定义了标准的输⼊/输出对象。
std::cin 是istream类的对象，它主要面向窄字符（narrowcharacters(oftypechar)）的标准输⼊流。
std::cout 是ostream类的对象，它主要面向窄字符的标准输出流。
std::endl 是⼀个函数，流插⼊输出时，相当于插⼊⼀个换⾏字符加刷新缓冲区。
<< 是流插⼊运算符，>> 是流提取运算符。（C语⾔还⽤这两个运算符做位运算左移/右移）
使⽤C++输⼊输出更⽅便，不需要像printf/scanf输⼊输出时那样，需要⼿动指定格式，
C++的输⼊输出可以⾃动识别变量类型(本质是通过函数重载实现的)，其实最重要的是
C++的流能更好的⽀持⾃定义类型对象的输⼊输出。
cout/cin/endl等都属于C++标准库，C++标准库都放在⼀个叫std(standard)的命名空间中，
所以要通过命名空间的使⽤⽅式去⽤他们。
⼀般⽇常练习中我们可以使用using namespace std;，实际项⽬开发中不建议使用。
vs系列编译器在包含 iostream 间接包含了 stdio.h ，其他编译器可能会报错。

#include<iostream>int main()
{int i;double d;std::cin >> i >> d;std::cout << i << " " << d << std::endl;return 0;
}

在这里插入图片描述

#include<iostream>
using namespace std;int main()
{// 在io需求⽐较⾼的地⽅，如部分⼤量输⼊的竞赛题中，加上以下3⾏代码// 可以提⾼C++IO效率ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);return 0;
}

缺省参数

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

#include <iostream>
using namespace std;void Func(int a = 0)
{cout << a << endl;
}int main()
{Func();// 没有传参时，使⽤参数的默认值Func(1);// 传参时，使⽤指定的实参return 0;
}

在这里插入图片描述

#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;}//半缺省 - C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。
void Func2(int a, int b = 10, int c = 20)
{cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl;}int main()
{Func1();Func1(1);Func1(1, 2);Func1(1, 2, 3);cout << endl;Func2(1);Func2(1, 2);Func2(1, 2, 3);//带缺省参数的函数调⽤，C++规定必须从左到右依次给实参，不能跳跃给实参。//不支持//Func1(1, , 3);//Func2(1, , 2);return 0;
}

在这里插入图片描述

函数重载

C++⽀持在同⼀作⽤域中出现同名函数，但是要求这些同名函数的形参不同，
可以是参数个数不同或者类型不同。

#include <iostream>
using namespace std;//1. 参数类型不同
int Add(int x, int y)
{cout << "int Add(int x, int y)" << endl;return x + y;
}double Add(double x, double y)
{cout << "double Add(double x, double y)" << endl;return x + y;
}//2. 参数个数不同
void f()
{cout << "void f()" << endl;
}void f(int a)
{cout << "void f(int a)" << endl;
}//3. 参数类型顺序不同
void f(int a, char b)
{cout << "void f(int a, char b)" << endl;
}void f(char a, int b)
{cout << "void f(char a, int b)" << endl;
}int main()
{//1int x1 = 10, y1 = 20;double x2 = 3.1, y2 = 4.3;printf("%d\n", Add(x1, y1));printf("%lf\n", Add(x2, y2));//2f();f(1);//3f(10, 'b');f('a', 20);return 0;
}

在这里插入图片描述

返回值不同不能作为重载条件，因为调用时无法区分

void fxx()
{}int fxx()
{return 0;
}

在这里插入图片描述

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

void f1()
{cout << "void f1()" << endl;
}void f1(int a = 10)
{cout << "void f1(int a = 10)" << endl;
}int main()
{f1(1);//void f1(int a = 10)//error C2668: “f1”: 对重载函数的调用不明确/*f1();*/return 0;
}

引用

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

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

#include <iostream>
using namespace std;int main()
{int a = 10;//引用：b和c是a的别名int& b = a;int& c = a;// 也可以给别名b取别名，d相当于还是a的别名int& d = b;++d;//改变d的值都跟着改变cout << a << endl;cout << b << endl;cout << c << endl;cout << d << endl;//a、b、c、d的地址是相同的cout << &a << endl;cout << &b << endl;cout << &c << endl;cout << &d << endl;return 0;
}

在这里插入图片描述

引用的特性

引用在定义时必须初始化
一个变量可以有多个引用
引用一旦引用一个实体，再不能引用其他实体

int main()
{int a = 10;//error C2530: “ra”: 必须初始化引用/*int& ra;*/int& b = a;int c = 20;// 这里并非让b引⽤c，而是赋值，因为C++引⽤不能改变指向。b = c;cout << &a << endl;cout << &b << endl;cout << &c << endl;return 0;
}

在这里插入图片描述

引用的使用

//引用功能1：形参作为别名，影响实参
void swap(int& x, int& y)
{int tmp = x;x = y;y = tmp;
}//引用功能2：形参作为别名，减少拷贝，提高效率
typedef struct Node
{int val;struct Node* next;
}Node;void swap(Node& x, Node& y)
{Node tmp = x;x = y;y = tmp;
}

//引用功能3：返回值引用，影响实参
//引用功能4：返回值引用，减少拷贝，提高效率
int& ArrRet(int& x)
{return x;
}int main()
{int arr[] = { 1,2,3,4 };for (int i = 0; i < 4; i++){ArrRet(arr[i]) += 1;}for (int i = 0; i < 4; i++){cout << arr[i] << " ";}cout << endl;return 0;
}

在这里插入图片描述

#include <iostream>
using namespace std;//不能返回临时变量的引用，ret出了作用域就销毁了
//warning C4172: 返回局部变量的地址或临时 : ret
int& func()
{int ret = 0;return ret;
}

const引用

引用和指针涉及权限的放大和缩小，权限不能放大，权限可以缩小

int main()
{//引用//权限可以缩小int a = 0;int& a1 = a;//权限缩小const int& a2 = a;//权限不能放大const int b = 0;//无法从“const int”转换为“int &”/*int& b1 = b;*/const int& b2 = b;//这是赋值，不涉及权限的放大和缩小int x = b;//指针//权限可以缩小int c = 0;int* c1 = &c;//权限缩小const int* c2 = c1;//权限不能放大const int d = 0;//无法从“const int *”转换为“int *”/*int* d1 = &d;*/const int* d2 = &d;return 0;
}

int main()
{int x = 1;const int y = 2;double d = 3.14;const int& r1 = x;//权限缩小const int& r2 = y;const int& r3 = 10;//const引用也可以给常量取别名//所谓临时对象就是编译器需要⼀个空间暂存表达式的求值结果时//临时创建的⼀个未命名的对象，C++中把这个未命名对象叫做临时对象。//x * 10会产生一个临时对象，临时对象具有常性//编译报错：无法从“int”转换为“int &”//int& r4 = x * 10;const int& r4 = x * 10;//const引用也可以给临时对象取别名//浮点型d在进行类型的隐式转换，把整数部分给一个临时对象，然后把临时对象的内容给r5//编译报错：无法从“double”转换为“int &”/*int& r5 = d;*/const int& r5 = d;//const引用也可以给临时对象取别名return 0;
}

指令汇编角度，引用是用指针实现的

int main()
{int x = 1;int& r1 = x;r1 = 2;int* p1 = &x;*p1 = 3;return 0;
}

在这里插入图片描述

指针和引用的关系

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

inline

用inline修饰的函数叫做内联函数，编译时C++编译器在编译阶段会在调用的地方展开
内联函数，这样调用内联函数就不需要建立栈帧了，可以提高效率。
inline对于编译器而言只是一个建议，你加了inline编译器也可以选择在调用的地方不展开，
不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。inline适⽤于频繁
调⽤的短⼩函数，对于递归函数，代码相对多⼀些的函数，加上inline也会被编译器忽略。
C语言实现宏函数会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不⽅便
调试，C++设计了inline⽬的就是替代C的宏函数。
inline不建议声明和定义分离到两个⽂件，分离会导致链接错误。因为inline在编译时被展开了，
所以就没有函数地址，链接时会出现报错。
vs编译器debug版本下，默认是不展开inline的，这样⽅便调试，debug版本想展开需要设置⼀下
以下两个地⽅。

在这里插入图片描述

#include <iostream>
using namespace std;inline int Add(int x, int y)
{int ret = x + y;ret += 1;ret += 1;return ret;
}int main()
{//可以通过汇编观察程序是否展开//有call Add语句就是没有展开，没有就是展开了int ret = Add(1, 2);cout << ret << endl;return 0;
}

在这里插入图片描述

inline int Add(int x, int y)
{int ret = x + y;ret += 1;ret += 1;ret += 1;ret += 1;ret += 1;ret += 1;ret += 1;ret += 1;return ret;
}

在这里插入图片描述
普通函数
F.h

	void f2(int x);

F.cpp

	void f2(int x){cout << x << endl;}

test.cpp

	f2(2);

内联函数
F.h

	inline void f1(int x);

F.cpp

	inline void f1(int x){cout << x << endl;}

test.cpp

	//f1在编译时被展开，就没有函数地址，链接时会出现报错f1(1);

原因：声明和定义分离到两个⽂件，导致链接错误。
解决办法：把函数定义直接放在.h文件中
F.h

inline void f1(int x)
{cout << x << endl;
}

static修饰函数
F.h

	static void f3(int x);

F.cpp

	static void f3(int x){cout << x << endl;}

test.cpp

	//error C2129: 静态函数“void f3(int)”已声明但未定义f3(3);

原因：static修饰的函数具有内部链接属性，只能在当前文件可见。
解决办法：把函数定义直接放在.h文件中
F.h

static void f3(int x)
{cout << x << endl;
}

nullptr

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

#ifndef 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(intx)，因此与程序的初衷相悖。f((void*)NULL);
调⽤会报错。

#include <iostream>
using namespace std;void f(int x)
{cout << "void f(int x)" << endl;
}void f(int* ptr)
{cout << "void f(int* ptr)" << endl;
}int main()
{f(0);f(NULL);//编译报错：error C2665 : “f”: 没有重载函数可以转换所有参数类型/*f((void*)NULL);*/return 0;
}