文章目录
前言：
C++ 入门 hello world!
#include<iostream>
using namespace std;
int main()
{
cout << "Hello World!" << endl;
return 0;
}
一、 命名空间
1. 命名空间的定义
定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{ }即可，{ }中即为命名空间的成员。
命名空间解决了 C语言中的命名冲突问题
例如：
出现命名冲突的原因：
当然，在引入在第三方库时，C语言也容易出现重定义现象；
解决方法：将命名冲突的变量放到命名空间域中
上图中 namespace lisi 中的 lisi 是 命名空间的名字
- 命名空间中可以定义变量/函数/类型
- 命名空间可以嵌套
- 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中
关于域： 有全局域、局部域、命名空间域、类域。全局和局部域 会影响 生命周期和访问，命名空间域影响访问。
不同的域可以出现相同的变量名，相同域不可以出现相同的变量名
编译器的搜索原则：
在未指定域的情况下，先在当前局部搜索，再去全局域搜索。如果指定域，直接去指定域搜做。
当只有 ::变量 时 默认去全局域搜素该变量
2. 命名空间的使用
(1) 加命名空间名称和作用域限定符
int main()
{
int z = 10;
printf("rand = %d\n", lisi::rand);
return 0;
}
lisi是 命名空间名称 ，:: 是作用域限定符
(2) 使用using将命名空间中某个成员引入
#include<stdio.h>
namespace N
{
int a = 10;
int b = 20;
}
using N::a; //将 N::a 引入当前作用域（全局作用域），后续代码可以直接使用 a 而无需写 N::a
int main()
{
int x = 10;
printf("a = %d\n",a);
printf("b = %d\n",N::b);
return 0;
}
例如： 当我们只想使用 cout 和 cin，只需将这两个进行展开即可
#include<iostream>
using std::cout;
using std::cin;
using std::endl;
int main()
{
int a;
cin >>a;
cout <<a<< endl;
return 0;
}
(3) 使用using namespace 命名空间名称 引入
也就是展开命名空间
#include<stdio.h>
namespace N
{
int a = 10;
int b = 20;
}
using namespace N; //将命名空间展开
int main()
{
int x = 10;
printf("a = %d\n",a);
printf("b = %d\n",b);
return 0;
}
注意：在定义结构体的时候
xx::struct Node head; 这种是不对的。应是 struct xx::Node head;
当我们使用
#include<iostream>
using namespace std;
std 是所有C++库命名空间
当只有#include < iostream > 时,我们需要指定命名空间
#include<iostream>
int main()
{
std::cout << "Hello World!" << std::endl;
std::cout << "Hello World!" << std::endl;
std::cout << "Hello World!" << std::endl;
std::cout << "Hello World!" << std::endl;
std::cout << "Hello World!" << std::endl;
return 0;
}
上述一直指定命名空间，感觉有些冗余
这里介绍比较方便的写法 是，将命名空间进行展开 (方便练习C++)
#include<iostream>
using namespace std;
int main()
{
cout << "Hello World!" << endl;
cout << "Hello World!" << endl;
cout << "Hello World!" << endl;
cout << "Hello World!" << endl;
cout << "Hello World!" << endl;
return 0;
}
二、 C++的输入和输出
cin 和 cout 标准的C++的输入和输出
#include<iostream>
using namespace std; //std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
int main()
{
int n = 0;
cin >> n; //输入
cout << n << endl; //输出并换行
return 0;
}
注意事项：
- <<是流插入运算符，>>是流提取运算符 (这里使用了运算符的复用，当之前的左移右移仍然保留)
- cout(console out)标准输出对象(控制台) 和 cin标准输入对象(键盘) 必须包含 < iostream >头文件以及按命名空间使用方法使用std 。
- cout和cin是全局的流对象，endl(end line)是特殊的C++符号，表示换行输出，他们都包含在包含头文件中
- C++的输入输出可以自动识别变量类型,不需要再去控制格式了
- 实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载等知识(后面的IO流会介绍)。
注意：关于cout和cin还有很多更复杂的用法，比如控制浮点数输出精度，控制整形输出进制格式等
等。因为C++兼容C语言的用法，所以如果不强制使用C++，可以使用C语言中的printf和scanf。
三、 缺省参数 (默认参数)
1. 缺省参数概念
缺省参数： 是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参时，则采用该形参的缺省值，否则使用指定的实参。
2. 缺省参数的分类
(1) 全缺省参数
函数实参一个没有传，采用形参的缺省值
(2) 半缺省参数
半缺省必须 从右往左连续给
注意：
- 缺省参数不能间隔着给
- 缺省参数不能在函数声明和定义中同时出现(有缺省参数时，要放在函数声明处)
- 缺省值必须是常量或者全局变量
四、 函数重载
在C语言中是不允许同名函数存在的，然而在C++中允许同名函数，要求：函数名相同，参数不同，构成函数重载
函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同。
函数重载常见情况
(1) 参数类型不同
#include<iostream>
using namespace std;
int Add(int x,int y)
{
return x + y;
}
double Add(double x,double y)
{
return x + y;
}
int main()
{
//参数类型不同
int int_ret = Add(1,2);
double double_ret = Add(1.1,2.1);
cout << int_ret << endl;
cout << double_ret << endl;
return 0;
}
(2) 参数个数不同
#include<iostream>
using namespace std;
int Add(int x, int y, int z)
{
return x + y + z;
}
int Add(int x, int y)
{
return x + y;
}
int main()
{
//参数个数不同
int ret_3 = Add(1, 2,3);
int ret_2 = Add(1,2);
cout << ret_3 << endl;
cout << ret_2 << endl;
return 0;
}
(3)参数的顺序不同
#include<iostream>
using namespace std;
void Print(int left,char right)
{
cout << "int char" << endl;
cout << "left:" << left << endl;
cout << "right:" << right << endl;
}
void Print(char right, int left)
{
cout << "char int" << endl;
cout << "right:" << right << endl;
cout << "left1:" <<left<< endl;
}
int main()
{
//参数顺序不同
Print(5,'a');
Print('a', 5);
return 0;
}
注意： 如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器无法区分。
我们知道C语言不支持函数重载，在链接时，直接用函数名去寻找地址，当有同名函数的时候，是区分不开的。
C++是采用了名字修饰规则，函数名字引入参数类型(在不同平台上的名字修饰规则是不同的)
在linux环境下，采用gcc编译完成后，函数名字的修饰没有发生改变 (编译C语言)
采用C++编译器编译后结果 ( 编译C++ )
g++ -o testcpp test.cc
objdump -S testcpp
我们可以看出gcc的函数修饰后名字不变。而g++的函数修饰后变成【_Z+函数长度+函数名+类型首字母】
在vs下的命名规则 
windows下vs编译器对函数名字修饰规则相对复杂难懂。
五、 引用
1. 引用的概念
引用(取别名)：引用是给已经存在的变量取了一个别名，不是新定义一个变量，编译器不会为引用变量开辟内存空间，和所引用的变量共用一块内存空间。
例如：张三，小名叫：小张 。张三和小张都是只一个人。
类型& 引用变量名 = 引用实体；//这里引用变量名就是该变量的别名
例:
//引用
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int& b = a; //引用，b是a的别名
cout << b << endl;
return 0;
}
输出结果: 10
我们通过打印a,b这两个地址进行打印，查看地址是否一致
注意：引用类型必须和引用实体是同种类型的
2. 引用的特性
- 引用在定义时必须初始化
- 一个变量可以有多个引用
- 引用一旦引用一个实体，再不能引用其他实体
-
引用在定义时必须进行初始化
int& b; //这种写法是错误的 int& b = a; //引用在定义时必须初始化 -
一个变量可以有多个引用(就像一个人的外号可以有多个，但是都是指的是同一个人)
int a = 10; int& b = a; //引用，b是a的别名 int& c = a; //引用，c也是a的别名
-
引用一旦引用一个实体，再不能引用其他实体
也就是当引用一个变量时，该引用不能再去引用其他变量int a = 10; int x = 20; int& b = a; //引用，b是a的别名 int& b = x; //error ,这样会导致重定义，多次初始化
关于常量引用
//int& z = 10; //error 常量不能引用
const int a = 100;
//int& b = a; //error,编译时出错，a为常量
const int& b = a; //正确写法
int ra = 10;
//double& b = ra; //error, 引用类型不同
3. 引用的使用
(1) 引用作参数
例如: 交换两个数
在C语言中，
void swap(int* x ,int* y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
int main()
{
int a = 10;
int b = 20;
swap(&a,&b); //把地址传过去
return 0;
}
交换两个数要把地址传过去，形参是实参的临时拷贝，只有把地址传过去，参数才可以改变。
在C++中，使用引用，引用和原值是共用一块内存空间
void swap(int& x,int &y) //引用做参数
{
int tmp = x;
x = y;
y = tmp;
}
int main()
{
int a = 10;
int b = 20;
swap(a,b);
return 0;
}
这里的x和y分别是a和b的别名
上述是给整型取别名，也可以给指针取别名
//void PushBack(struct Node** pphead,int x){} //C语言使用二级指针
void PushBack(struct Node*& phead,int x) //C++,使用引用给指针取别名
{
//phead = newnode;
//...
}
小总结：引用做参数，a.做输出型参数 b.对象比较大时，减少拷贝，提高效率。
(2) 引用作返回值
int& func() //返回值类型 int& ，传引用返回
{
int a = 1000;
return a;
}
int main()
{
int ret = func();
cout << ret << endl;
return 0;
}
int func 传值返回时(返回的是拷贝)，函数栈帧的销毁，会导致a的值可能是随机值。
int& func 传引用返回，返回a的别名，但是指向的内存空间没有改变，函数栈帧的销毁，内存返回给操作系统，引用的值也变成了随机值。(出现了野引用)
什么情况下可以使用引用返回？
全局变量/静态变量/堆上的空间等可以作引用返回
小总结：
传值返回，传的是返回值的拷贝；传引用返回，传的是返回值的别名。
返回变量出了函数作用域，生命周期就到了要销毁 (局部变量)，不能用引用返回。
引用作返回值 a.修改返回对象 b.减少拷贝调高效率
4. 引用和指针的区别
int main()
{
//引用
int a = 10;
int& ra = a; //语法层面不开空间
ra = 20;
//指针
int* pa = &a; //语法层面开空间
*pa = 20;
return 0;
}
语法上(规定用法) :
(1) 引用是别名, 不开空间，指针是地址, 需要开辟内存空间
(2) 引用必须初始化，指针可以初始化也可以不初始化
(3) 引用不能改变指向，指针可以改变指向
(4) 引用相对更安全，没有空引用，但是有空指针，容易出现野指针，但不容易出现野引用
(5) 在sizeof中含义不同，引用结果引用类型的大小，但指针始终是地址空间所占字节个数
(6) 引用++，引用的实体增加1，指针++即指针向后偏移一个类型的大小
(7) 有多级指针，但是没有多级引用
底层上(汇编) :
引用的底层使用指针实现的
汇编层面上，没有引用，都是指针，引用编译后也转换成指针了。
引用和指针的功能类似，但是引用不能完全替代指针，因为引用定义后不能改变指向。例如：在单链表中，删除链表中的某一个结点，需要让指针指向要删除结点的下一个结点(改变指针的指向)。但是引用是无法进行改变指向的。
然而在java和python中实现链表是通过引用，java和python中的引用是允许改变指向的。
六、 内联函数
内联函数概念
内联函数：以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数可以提升程序运行的效率。
在C语言中，如果进行多次调用函数，那么会多次建立函数栈帧，C语言是通过宏函数来解决这个问题。因为宏会在预处理阶段进行宏的替换，这样就不会建立函数栈帧了。
宏的优点：
没有函数栈帧的创建，提高效率
但是宏也是有一些缺点的
宏的缺点：
语法复杂，坑很多，不容易控制；不能调试；没有 类型安全的检查
C++替代宏的技术：可以使用常量定义 (const enum) ; 短小函数定义 换用内联函数
为了减少使用宏，C++给出了内联函数
在C++中，在调用内联函数的地方展开，没有函数调用建立栈帧的开销
为什么内联函数适合短小函数(通常1~5行)呢？
假设 func函数有100行(大型函数)，项目中有1w个调用该函数的位置
内联展开了 100*1w = 100w行
不使用内联展开 100+1w = 1.01w行
大的函数就影响很大，不适合使用内联函数，所以 短小函数可以换用内联函数
在内联函数在长一点的函数和递归函数是不会展开的
内联函数特性
-
内联函数(inline)是一种以空间换时间的做法，在编译阶段，会把函数展开(在调用点处)。优点：减少了函数栈帧的开销，提高效率；缺点：目标文件可能会增大。
-
内联函数适合较小代码量的函数
-
inline不建议声明和定义分离，分离会导致链接错误，因为inline被展开，就没有函数地址，链接时的符号表就找不到了。
例如：//test.cpp #include "test.h" int main() { func(); return 0; } //test.h #pragma once //避免头文件被重复包含，可以提高运行效率 #include<iostream> using namespace std; inline void func(); //error //func.cpp #include "test.h" void func() { cout << "func()" << endl; }因为inline函数展开，汇编call调用时没有函数地址
如果要在test.h文件写函数，代码量较小的可以用内联(声明和定义不分离)，大的就使用static (链接属性，只在当前文件可见)
七、auto关键字
在C++中，auto有许多作用，但是最常用的是用于类型推导。
int i = 0;
auto k = i; //auto 在这里的作用就是自动(识别)推导类型
void(*pf1)(int, int) = func; //函数指针
auto pf2 = func; //自动识别函数指针
//打印类型进行验证一下、
cout << typeid(pf1).name() << endl;//void (__cdecl*)(int,int)
cout << typeid(pf2).name() << endl;//void (__cdecl*)(int,int)
//std::map<std::string, std::s>::iterator it = dict.begin();
//auto it = dict.begin();
当然上述也可以使用C语言中的typedef 类型重命名，但是当计算出表达式的值的时候，进行赋值( 就需要知道数据类型 )，在一些项目中使用typedef没有那么容易，但是 auto关键字可以进行自动推导。
auto从C++11标准及更高标准下可以作返回类型
auto func(int a,int b) {}
注意：
用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。
auto的缺点：
(1) auto不能作为函数的参数
// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a){}
(2) auto不能用来直接声明数组
int a[] = {1,2,3};
auto b[] = {4,5,6}; //error
八、 基于范围的for循环(C++11)
范围for的语法
C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。
int a[] = {1,2,3,4,5,6};
int b[] = {1,2,3,4,5,6};
//普通的for循环
for (int i = 0; i < sizeof(a) / sizeof(a[0]);i++)
{
a[i] *= 2;
}
for (int i = 0;i< sizeof(a) / sizeof(a[0]);i++)
{
cout << *(a + i) <<' '; //打印结果：2 4 6 8 10 12
}
//范围for的使用 （C++11）
for (int e:b) //依次取数组中赋值给e,自动迭代，自动判断结束
e *= 2;
for (int e : b)
cout << e << ' '; //打印结果：1 2 3 4 5 6
上述范围for的使用C++11也进行了数值乘2，但是打印结果没有发生变化。原因是: 因为是从数组中取出赋值给e，并没有改变数组中的数据，所以打印还是原值。
要想修改原数组的值，则需要使用引用
for (int& e : b) //依次取数组中赋值给e,自动迭代，自动判断结束
e *= 2;
for (int e : b)
cout << e << ' '; //打印结果2 4 6 8 10 12
//当然也可以换成auto
for (auto& e : b) //依次取数组中赋值给e,自动迭代，自动判断结束
e *= 2;
for (auto e : b)
cout << e << ' '; //打印结果2 4 6 8 10 12
范围for循环可以用continue来结束本次循环，也可以用break来跳出整个循环。
for循环迭代的范围必须是确定的
九、 指针空值
声明一个变量及时初始化是一个C/C++的一个好的编程习惯，否则可能会出现不可预料的错误，例如未初始化指针。
//初始化指针
int *p1 = NULL;
int* p2 = 0;
然而在C++98标准中出现了关于指针的bug
void f(int i)
{
cout << "f(int)" << endl;
}
void f(int* i)
{
cout << "f(int*)" << endl;
}
int main()
{
f(0);
f(NULL);
return 0;
}
打印结果:
f(int)
f(int)
发现都调用了第一个函数
分析：
f((int *)NULL); //打印 f(int*)
随后在C++11标准中出现了 nullptr
f(nullptr); //打印 f(int*)
int* p = nullptr;
nullptr 的主要优势 在于它提供了更好的类型安全性。它只能被赋值给指针类型，而不能被赋值给整数类型，这有助于减少因错误地将NULL或0用于非指针类型而引起的问题。此外，使用 nullptr 可以避免与某些平台上的空指针值冲突。
在C++11标准中，sizeof(nullptr) 和sizeof((void*)0)所占字节数相同，后续表示指针空值时，建议使用nullptr。
扫一扫
1065
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
