C++入门详细版

欢迎来到干货小仓库！！

一分耕耘一分收获，离自己的目标越来越近。

passion！passion！！passion！！！

1.命名空间

由于C语言无法避免名字或者函数重复等问题，当有多个工程时，会导致很多冲突。故祖师爷C++之父本贾尼·斯特劳斯特卢普,设定了命名空间，与外部变量或者函数冲突都可以避免。

因此就有了命名空间。

1.1命名空间

定义命名空间，需要使用到namespace****关键字，后面跟命名空间的名字，然**后接一对****{}**即可，{}

中即为命名空间的成员。

①命名空间中可以定义变量/函数/类型。

②命名空间可以嵌套。

③ 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。

(注意：一个工程中的test.h和上面test.cpp中两个N1会被合并成一个)

cpp 复制代码

namespace bit
{
	// 命名空间中可以定义变量/函数/类型
	int a = 0;
	int b = 1;
	int Add(int left, int right)
	{
		return left + right;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
}

注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。

1.2命名空间使用

不能直接使用命名空间中的内容。例如：

cpp 复制代码

namespace N
{
	// 命名空间中可以定义变量/函数/类型
	int a = 0;
	int b = 1;
	int Add(int left, int right)
	{
		return left + right;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
}
int main()
{
	// 编译报错：error C2065: "a": 未声明的标识符
	printf("%d\n", a);
	return 0;
}

命名空间的使用有三种方式：
以下的命名空间N，沿用上面的。
① 加命名空间名称+作用域限定符(::)

cpp 复制代码

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

②使用using将命名空间中某个成员引入(相当于将某个变量变成全局的)

cpp 复制代码

using N::b;//只是将命名空间N中的b展开
int main()
{
    printf("%d\n", b);
    return 0;    
}

③使用using namespace 命名空间名称引入(相当于将命名空间中的所有内容变成全局的)

cpp 复制代码

using namespce N;
int main()
{
    //访问命名空间中的内容就不需要访问限定符和展开了
    printf("%d\n", a);
    printf("%d\n", b);
    Add(10, 20);
    return 0;    
}

2.C++输入&输出

先记住，需要包头文件和命名空间的使用。

cpp 复制代码

#include<iostream>
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std;
int main()
{
    cout<<"Hello world!!!"<<endl;
    return 0;
}

说明：

使用 cout 标准输出对象 ( 控制台 ) 和 cin 标准输入对象 ( 键盘 ) 时，必须包含 < iostream > 头文件
以及按命名空间使用方法使用 std 。

cout 和 cin 是全局的流对象， endl 是特殊的 C++ 符号，表示换行输出，他们都包含在包含 <
iostream > 头文件中。

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

使用 C++ 输入输出更方便，不需要像 printf/scanf 输入输出时那样，需要手动控制格式。
C++ 的输入输出可以自动识别变量类型。

实际上 cout 和 cin 分别是 ostream 和 istream 类型的对象， >> 和 << 也涉及运算符重载等知识，
到了类和对象会有详细学习。
std 命名空间的使用惯例：
std 是 C++ 标准库的命名空间，如何展开 std 使用更合理呢？

在日常练习中，建议直接 using namespace std 即可，这样就很方便。
using namespace std 展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型 / 对
象 / 函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模
大，就很容易出现。所以建议在项目开发中使用，像 std::cout这样使用时指定命名空间 +
using std::cout展开常用的库对象/类型等方式。

3.缺省参数

3.1缺省参数的概念

缺省参数是 声明或定义函数时 为函数的 参数指定一个缺省值 。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。

cpp 复制代码

#include<iostream>
using namespace std;

void Func(int a = 0)  //缺省参数
{
	cout << a << endl;
}
int main()
{
	Func();    // 没有传参时，使用参数的默认值
	Func(10);  // 传参时，使用指定的实参
	return 0;
}

3.2缺省参数的分类

①全缺省

cpp 复制代码

void Date(int year=2025,int month=1,int day=20)
{
    
    cout<<"year = "<< year <<endl;
    cout<<"month = "<< month <<endl;
    cout<<"day = "<< day <<endl;
}

②半缺省

cpp 复制代码

void Date(int year,int month=1,int day=20)
{
    
    cout<<"year = "<< year <<endl;
    cout<<"month = "<< month <<endl;
    cout<<"day = "<< day <<endl;
}

注意:

半缺省参数必须从右往左依次来给出，不能间隔着给
缺省参数不能在函数声明和定义中同时出现 (在.h中出现即可)
缺省值必须是常量或者全局变量
C语言不支持（编译器不支持）

4.函数重载

4.1函数重载概念

函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这

些同名函数的**形参列表****(参数个数或类型或类型顺序)**不同，常用来处理实现功能类似数据类型

不同的问题。

构成函数重载的要求：

①参数类型不同

②参数个数不同

③类型顺序不同

注意：

①返回值没有要求。

②全缺省

4.2C++支持函数重载的原理--名字修饰

为什么C语言不支持，CPP支持重载，CPP怎么支持的呢？

①编译链接过程

②函数名修饰规则

5.引用

5.1引用的概念

引用不是新定义一个变量，而 是给已存在变量取了一个别名 ，编译器不会为引用变量开辟内存空
间，它和它引用的变量 共用同一块内存空间。
类型& 引用变量名(对象名) = 引用实体；

5.2引用特性

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

5.3常引用

①引用过程中，权限可以平移。
②引用过程中，权限可以缩小。
③引用过程中，权限不可以放大。

5.4使用场景

①做参数

cpp 复制代码

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}

②做返回值

cpp 复制代码

int& Count()
{
   static int n = 0;
   n++;
   // ...
   return n;
}

注意：下面代码输出什么结果？为什么？

cpp 复制代码

int& Add(int a, int b)
{
    int c = a + b;
    return c;
}
int main()
{
    int& ret = Add(1, 2);
    Add(3, 4);
    cout << "Add(1, 2) is :"<< ret <<endl;
    return 0;
}

注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用
引用返回，如果已经还给系统了，则必须使用传值返回。
引用与指针的不同：

引用概念上定义一个变量的别名，指针存储一个变量地址。

引用在定义时 必须初始化 ，指针没有要求

引用在初始化时引用一个实体后，就 不能再引用其他实体 ，而指针可以在任何时候指向任何一个同类型实体

没有 NULL 引用，但有 NULL 指针

在 sizeof 中含义不同 ：引用结果为 引用类型的大小 ，但指针始终是 地址空间所占字节个数 (32 位平台下占4 个字节 )

引用自加即引用的实体增加 1 ，指针自加即指针向后偏移一个类型的大小

有多级指针，但是没有多级引用

访问实体方式不同， 指针需要显式解引用，引用编译器自己处理

引用比指针使用起来相对更安全

6.内联函数

6.1概念

以inline****修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的 调用。

6.2特性

inline 是一种 以空间换时间 的做法，如果编译器将函数当成内联函数处理，在 编译阶段，会
用函数体替换函数调用 ，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运
行效率。

inline 对于编译器而言只是一个建议，不同编译器关于 inline 实现机制可能不同 ，一般建
议：将 函数规模较小 ( 即函数不是很长，具体没有准确的说法，取决于编译器内部实现 ) 、不
是递归、且频繁调用 的函数采用 inline 修饰，否则编译器会忽略 inline 特性。

inline 不建议声明和定义分离，分离会导致链接错误。因为 inline 被展开，就没有函数地址
了，链接就会找不到。

cpp 复制代码

// F.h
#include <iostream>
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 中被引用

7.auto关键字(C++11)

C++11 中，标准委员会赋予了 auto 全新的含义即： auto 不再是一个存储类型指示符，而是作为一 个新的类型指示符来指示编译器， auto 声明的变量必须由编译器在编译时期推导而得 。

cpp 复制代码

int TestAuto()
{
    return 10;
}
int main()
{
    int a = 10;
    auto b = 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;
}

7.1auto使用规则

auto与指针和引用结合起来使用
用 auto 声明指针类型时，用 auto 和 auto* 没有任何区别，但用 auto 声明引用类型时则必须
加 &

在同一行定义多个变量
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译
器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量 。

cpp 复制代码

int main()
{
    auto a = 1, b = 2; 
    auto c = 3, d = 4.0;  // 该行代码会编译失败，因为c和d的初始化表达式类型不同
   
    return 0;
}

7.2auto不能推导的场景

auto不能作为函数的参数

cpp 复制代码

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}

auto不能直接用来声明数组

cpp 复制代码

int main()
{
	int a[] = { 1,2,3 };
	auto b[] = { 4，5，6 };

	return 0;
}

为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有

lambda表达式等进行配合使用。

8.基于范围的for循环(C++11)

8.1范围for语法

cpp 复制代码

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int n = sizeof(arr) / sizeof(int);
	//C语言打印数组
	for (int i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");

	//CPP范围for
	for (auto e : arr)
	{
		printf("%d ", e);
	}

	return 0;
}

8.2范围for的使用条件

for****循环迭代的范围必须是确定的

对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供

begin和end的方法，begin和end就是for循环迭代的范围。

注意：以下代码就有问题，因为for的范围不确定

cpp 复制代码

void TestFor(int array[])
{
    for(auto& e : array)
        cout<< e <<endl;
}

迭代的对象要实现**++和==**的操作。(关于迭代器这个问题，后面会出文章在细讲)

9.指针空值--nullptr(C++11)

程序本意是想通过 f(NULL) 调用指针版本的 f(int*) 函数，但是由于 NULL 被定义成 0 ，因此与程序的初衷相悖。
在 C++98 中，字面常量 0 既可以是一个整形数字，也可以是无类型的指针 (void*) 常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。

注意：
1. 在使用 nullptr 表示指针空值时，不需要包含头文件，因为 nullptr 是 C++11 作为新关键字引入 的。
2. 在 C++11 中， sizeof(nullptr) 与 sizeof((void*)0) 所占的字节数相同。
3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用 nullptr 。

觉得不错，别忘记点赞+收藏咯！！欢迎大家的询问和指教，谢谢大家！！

C++入门 详细版

欢迎来到干货小仓库！！

一分耕耘一分收获，离自己的目标越来越近。

passion！passion！！passion！！！

1.命名空间

1.1命名空间

1.2命名空间使用

2.C++输入&输出

3.缺省参数

3.1缺省参数的概念

3.2缺省参数的分类

4.函数重载

4.1函数重载概念

4.2**C++支持函数重载的原理--**名字修饰

5.引用

5.1引用的概念

5.2引用特性

5.3常引用

5.4使用场景

6.内联函数

6.1概念

6.2特性

7.auto关键字(C++11)

7.1auto使用规则

7.2auto不能推导的场景

8.基于范围的for循环(C++11)

8.1范围for语法

8.2范围for的使用条件

9.指针空值--nullptr(C++11)

觉得不错，别忘记点赞+收藏咯！！欢迎大家的询问和指教，谢谢大家！！

C++入门详细版

4.2C++支持函数重载的原理--名字修饰