C++学习笔记(一）——入门篇
目录
1. 命名空间
1.1 命名空间定义
1.2 命名空间使用
2. C++输入&输出
3. 缺省参数
3.1 概念
3.2 缺省参数分类
4. 函数重载
4.1 概念
4.2 名字修饰
5. extern "C"(下一章做重点介绍）
6. 引用
6.1 概念
6.2 引用特性
6.3 常引用
6.4 使用场景
6.5 引用和指针的区别
7. 内联函数
7.1 概念
7.2 特性
8. auto关键字(C++11)
8.1 简介
8.2 auto的使用规则
8.3 auto不能推导的场景
9. 基于范围的for循环(C++11)
9.1 范围for的语法
9.2 for范围的使用条件
10. 指针nullptr(C++11)
10.1 C++98中的指针空值
1. 命名空间
在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将
都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行
本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。
如下图所示:
C语言是没有办法很好的解决此问题, 因此C++提出了一个新语法，命名空间.
1.1 命名空间定义
定义命名空间需要使用到namespace关键字,后面跟命名空间的名字,然后接一对{}即可,{}即为命名空间成员。
//1.普通的命名空间
//定义了一个叫qk的命名空间-域
namespace qk {
//命名空间可以定义函数/变量/类型
int rand = 1;//他们还是全局变量,放到静态区
int sub(int a, int b)
{
return a - b;
}
struct node {
struct node* next;
int data;
};
}
//命名空间可以嵌套
namespace n1 {
int a;
int b;
int add(int m, int n)
{
return m + n;
}
namespace n2 {
int c;
int d;
int sub(int g, int f)
{
return g - f;
}
}
}
//同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
namespace n3 {
int mul(int a, int b)
{
return a * b;
}
}1.2 命名空间使用
首先说一下最常见的一种错误用法，例如:
namespace qk
{
int a=10;
int b=20;
int sub(int c,int d)
{
return c-d;
}
}
int main()
{
printf("%d",a);//该编译错误,无法识别a
}命名空间的使用有三种方式:
- 加命名空间名称及作用域限定符(::)【安全性高,但使用起来不方便】
int main()
{
printf("%d",qk::a);
return 0;
}- 使用using将命名空间中最常用的成员引入【安全性高,并且可以减少一些麻烦】
using N::b;
int main()
{
printf("%d",b);
return 0;
}- 使用using namespace命名空间引入 【安全性低,平常练习可以用用,但做项目不推荐使用】
using namespace qk;
int main()
{
sub(10,20);
return 0;
}易错区:
1.在命名空间中定义的成员是全局变量，并放在静态区;
2.命名空间可以初始化,但是不能赋值;
namespace qk
{
int rand=10;//可以初始化
rand=5;//但是不可以赋值
}2. C++输入&输出
C++是包含C语言的，因此在C++中同样可以使用C语言输入和输出.
- 使用cout标准输出和cin标准输入时,必须包含
头文件 以及std标准命名空间;- 这里我直接使用using namespace将命名空间展开,平常练习代码推荐使用;
- C++中的输入和输出更加方便,可以自动识别类型,小数点后有几位就几位不会向后估读;
- endl和C语言中的换行符'\n'作用一样;
- <<:流插入运算符，>>:流提取运算符;
3. 缺省参数
3.1 概念
缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时,如果没有指定实参则采用该默认值,否则使用指定的实参。
3.2 缺省参数分类
-
全缺省参数
//全缺省参数
void qk(int a = 10, int b = 20, int c = 30)
{
cout << "a=" << a << endl;
cout << "b=" << b << endl;
cout << "c=" << c << endl;
}- 半缺省参数
//半缺省参数 -- 缺省部分参数 -- 必须从右往左缺省,必须连续缺省
void qk(int a, int b = 20, int c = 30)
{
cout << "a=" << a << endl;
cout << "b=" << b << endl;
cout << "c=" << c << endl;
}注意:
- 半缺省参数必须从右往左依次给出,不能间隔着给；
- 缺省参数不能在函数声明和定义同时给出;
- 缺省值必须是常量或者是全局变量;
- C语言不支持;
/这均是错误的写法
void qk(int a = 10, int b, int c)
void qk(int a = 10, int b, int c = 30)
qk(, 2, );
qk(, , 3);
//heap.h(声明)
void qk(int a = 10);
// heap.c(定义)
void qk(int a = 20)
{}
// 注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那
//个缺省值。4. 函数重载
自然语言中，一个词可以有多重含义，人们可以通过上下文来判断该词真实的含义，即该词被重载了。
比如：以前有一个笑话，国有两个体育项目大家根本不用看，也不用担心。一个是乒乓球，一个是男足。前者是“谁也赢不了！”，后者是“谁也赢不了!"
4.1 概念
函数重载:是函数的一种特殊情况,C++允许在同一作用域中声明几个功能类似的同名函数,这些同名函数的形参列表(参数个数或类型或顺序)必须不同,常用来处理实现功能类似数据类型不同的问题.
//1.参数类型不同
int Add(int left, int right)
{
cout << "int Add(int left, int right)" << endl;
return left + right;
}
double Add(double left, double right)
{
cout << "double Add(double left, double right)" << endl;
return left + right;
}
//2.参数个数不同
void f()
{
cout << "f()" << endl;
}
void f(int a)
{
cout << "f(int a)" << endl;
}
//3.参数顺序不同
void f(int a, char b)
{
cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
cout << "f(char b, int a)" << endl;
}
下面函数属于函数重载吗？
//返回值不同，不能构成重载 -- 调用的时候不能区分
short Add(short left, short right)
{
return left + right;
}
int Add(short left, short right)
{
return left + right;
}
// 1、缺省值不同，不能构成重载
void f(int a)
{
cout << "f()" << endl;
}
void f(int a = 0)
{
cout << "f(int a)" << endl;
}
// 2、构成重载，但是使用时会有问题 ： f(); // 调用存在歧义
void f()
{
cout << "f()" << endl;
}
void f(int a = 0)
{
cout << "f(int a)" << endl;
}
int main()
{
// f(); // 调用存在歧义
f(1);
return 0;
}4.2 名字修饰
为什么C++支持函数重载,而C语言不支持函数重载？
在C/C++中,一个程序要运行起来要经历以下几个阶段:预处理,汇编,编译,链接.
1. 实际我们的项目通常是由多个头文件和多个源文件构成，而通过我们C语言阶段学习的编译链接，我们可以知道，【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译后链接前，a.o的目标文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么怎么办呢？
2. 所以链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就会到b.o的符号表中找Add的地址，然后链接到一起。
3. 那么链接时，面对Add函数，连接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规则。
4. 由于Windows下vs的修饰规则过于复杂，而Linux下gcc的修饰规则简单易懂，下面我们使用了gcc演示了这个修饰后的名字。
5. 通过下面我们可以看出gcc的函数修饰后名字不变。而g++的函数修饰后变成【_Z+函数长度+函数名+类型首字母】。
- 采用C语言编译器编译后结果
结论:在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变。
- 采用C++编译器编译后结果
结论:在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息
添加到修改后的名字中。
【拓展学习:C/C++函数调用约定和名字修饰规则】
C++的函数重载 - 吴秦 - 博客园
C/C++ 函数调用约定_狮子的专栏-CSDN博客_c 调用约定
通过这里我们就理解了C语言没办法支持重载,因为同名函数没办法区分。而C++是通过函数修饰规则来区分,只要参数不同,修饰出来的名字就不一样,就支持重载。
另外我们也了解了，为什么函数重载要求参数不同，而跟返回值没关系.
5. extern "C"(下一章做重点介绍）
有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern "C"，意思是告诉编译器，将该函数按照C语言规则来编译。
extern "C" int Add(int a, int b);
int main()
{
Add(1,2);
return 0;
}6. 引用
6.1 概念
引用不是新定义一个变量,而是给已经存在的变量取个别名,编译器不会为引用变量开辟内存空间,它和它引用的变量共用同一块内存空间.
类型& 引用变量名(对象名)=引用实体;
void qk()
{
int a = 10;
int& b = a;
printf("%p\n", &a);
printf("%p", &b);
}注意：引用类型必须和引用实体是同种类型的
6.2 引用特性
1.引用在定义时必须初始化
2.一个变量可以有多个引用
3.引用一旦引用了一个实体就不能引用其他实体
/1.引用时必须初始化
int a = 10;
//int& b; 未初始化错误
int& b = a;
//2.一个变量可以有多个引用
int a = 10;
int& b = a;
int& c = a;
int& d = b;
//3.一旦引用一个实体就不能引用其他实体
int a = 10;
int& b = a;
int c = 20;
b = c;//赋值,而不是引用6.3 常引用
常引用有以下几种情况:
- 隐式类型转换，需要在类型前加const，且这时引用的不是变量本身，而是隐式类型转换时的临时空间。
double a = 10.7;
const int& b = a;- 权限放大——不行
const int a=10;
int& b=a;- 权限缩小——可以
int a=10;
const int& b=a;- 权限不变——可以
const int a=10;
const int& b=a;总结:const type& 可以接收各种类型的对象
6.4 使用场景
1. 做参数 ——提高效率，形参的改变可以影响实参
// 1、引用做参数
// _Z4swappipi
void swap1(int* p1, int* p2) // 传地址
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
// _Z4swapriri
void swap2(int& r1, int& r2) // 传引用
{
int tmp = r1;
r1 = r2;
r2 = tmp;
}
// _Z4swapii
//void swap(int r1, int r2) // 传值
//{
// int tmp = r1;
// r1 = r2;
// r2 = tmp;
//} 
2.做返回值——提高效率，修改返回变量;
当前代码出现的问题:
1.存在非法访问,因为Add(1,2)的返回值是c的引用,所以Add栈帧销毁了以后，回去访问c的空间。
2.如果Add栈帧销毁后，清理空间,那么取c值的时候取到的就是随机值,给ret就是随机值。
注意：如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。
6.5 引用和指针的区别
在语法概念上引用就是一个别名,没有独立空间,和其引用实体共用一块空间
在底层实现上实际是有空间的,因为引用是按指针方式来实现的.
int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
}
我们来看一下引用和指针的对比:
引用和指针的不同点:
- 引用在定义时必须初始化，指针没有要求
- 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
- 没有NULL引用，但有NULL指针
- 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
- 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
- 有多级指针，但是没有多级引用
- 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
- 引用比指针使用起来相对更安全
7. 内联函数
7.1 概念
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率。
如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。不会有函数压栈的开销。
7.2 特性
- lnline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
- inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
- line不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。
// F.h
#include
using namespace std;
inline void f(int i);
// F.cpp
#include "F.h"
void f(int i)
{
cout << i << endl;
}
// main.cpp
#include "F.h"
int main()
{
f(10);
return 0;
}
// 链接错误：main.obj : error LNK2019: 无法解析的外部符号 "void __cdecl f(int)" (?
f@@YAXH@Z)，该符号在函数 _main 中被引用 8. auto关键字(C++11)
8.1 简介
在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它。
C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
int TestAuto()
{
return 10;
}
int main()
{
int a = 10;
auto b = a;//auto自动识别a的类型
auto c = 'a';
auto d = TestAuto();
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
cout << typeid(d).name() << endl;
//auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
return 0;
}[注意]：
使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。
8.2 auto的使用规则
1. auto与指针和引用结合起来使用用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
int main()
{
int x = 10;
auto a = &x; //int*
auto* b = &x;//int*
auto& c = x;//int
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
*a = 20;
*b = 30;
c = 40;
return 0;
}2. 在同一行定义多个变量当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
void TestAuto()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}8.3 auto不能推导的场景
1. auto不能作为函数的参数
// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}2. auto不能直接用来声明数组
void TestAuto()
{
int a[] = {1,2,3};
auto b[] = {4，5，6};
}9. 基于范围的for循环(C++11)
9.1 范围for的语法
在c++中要遍历一个数组,可以按照以下方式:
int array[] = { 1, 2, 3, 4, 5 };
//C/C++ 遍历数组
for (int i = 0; i < sizeof(array) / sizeof(int); ++i)
{
cout << array[i] << endl;
}C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。
int a[] = { 1,2,3,4,5 };
for (auto& e : a)
{
e++;//每个数加1
}
for (auto e: a)
{
cout << e << " " << endl;//{2,3,4,5,6}
}
return 0;注意:与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。
9.2 for范围的使用条件
for循环迭代的范围必须是确定的.对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。注意：以下代码就有问题，因为for的范围不确定
void qk(int array[])
{
for(auto& e : array)
cout<< e <10. 指针nullptr(C++11)
10.1 C++98中的指针空值
在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：
void TestPtr()
{
int* p1 = NULL;
int* p2 = 0;
// ……
}NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如:
void f(int)
{
cout<<"f(int)"< 
程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。
在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。
注意:
- 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的
- 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
- 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。
以上是c++入门的基础知识点，有不足的地方或者对代码有更好的见解，欢迎评论区留言共同商讨，共同进步！！ 