初识C++ - 技术栈

[1 · C++的起源与定义](#1 · C++的起源与定义)

[1 - 1 · 起源](#1 - 1 · 起源)

[1 - 2 · 定义](#1 - 2 · 定义)

[1 - 3 · 小结](#1 - 3 · 小结)

[2 · 命名空间](#2 · 命名空间)

[2 - 1 · namespace的价值](#2 - 1 · namespace的价值)

[2 - 2 · namespace的定义](#2 - 2 · namespace的定义)

[2 - 3 · 命名空间的使用](#2 - 3 · 命名空间的使用)

[3 · 输入 / 输出](#3 · 输入 / 输出)

[3 - 1 · C++的第一个程序](#3 - 1 · C++的第一个程序)

[4 · 缺省参数](#4 · 缺省参数)

[5 · 函数重载](#5 · 函数重载)

[5 - 1 · 构成函数重载的条件](#5 - 1 · 构成函数重载的条件)

[5 - 1 - 1 · 参数类型不同](#5 - 1 - 1 · 参数类型不同)

[5 - 1 - 2 · 参数个数不同](#5 - 1 - 2 · 参数个数不同)

[5 - 1 - 3 · 参数顺序不同](#5 - 1 - 3 · 参数顺序不同)

[5 - 2 · 会出问题的写法](#5 - 2 · 会出问题的写法)

[6 · 引用](#6 · 引用)

[6 - 1 · 引用的概念](#6 - 1 · 引用的概念)

[6 - 2 · 引用的特性](#6 - 2 · 引用的特性)

[6 - 3 · 引用的使用](#6 - 3 · 引用的使用)

[6 - 4 · const引用](#6 - 4 · const引用)

[6 - 5 · 指针和引用的关系](#6 - 5 · 指针和引用的关系)

[7 · inline](#7 · inline)

[8 · nullptr](#8 · nullptr)

1 · C++的起源与定义

1 - 1 · 起源

C++（读作"C plus plus"）由丹麦计算机科学家Bjarne Stroustrup于1980年代初期在贝尔实验室开发。其设计初衷是为C语言添加面向对象编程（OOP）支持，同时保留C的高效性和底层控制能力。

灵感来源 ：
Bjarne Stroustrup在开发分布式系统时，发现Simula语言具有优秀的抽象能力但效率较低，而C语言高效但缺乏抽象机制。因此，他尝试将Simula的面向对象特性 与C的系统编程能力结合。
早期名称 ：
最初称为"C with Classes"，后于1983年更名为C++（"++"表示C语言的增强）。
标准化历程 ：
C++于1998年通过ISO/IEC标准化（C++98），后续陆续发布了C++11、C++14、C++17和C++20等重大修订版本。

1 - 2 · 定义

C++是一种通用的、多范式编程语言，支持：

过程式编程：保留C语言的基础语法和流程控制。
面向对象编程（OOP）：支持封装、继承、多态等特性。
泛型编程 ：通过模板（template）实现类型无关的代码复用。
元编程：编译时计算（如模板元编程）。

核心特性：

零成本抽象：高级抽象（如类、模板）在运行时几乎不引入额外开销。
直接内存控制 ：支持指针和手动内存管理（如new/delete）。
兼容C语言：绝大多数C代码可直接在C++环境中编译运行。
强类型系统：支持静态类型检查，减少运行时错误。

1 - 3 · 小结

C++以C语言为基础，通过引入面向对象与泛型编程，成为兼顾性能与抽象的工业级语言，持续推动系统软件与高性能计算的发展。

2 · 命名空间

2 - 1 · namespace的价值

在C/C++中，变量、函数和类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。
C语言项目命名冲突是普遍存在的问题，C++引入namespace就是为了更好的解决这样的问题：

复制代码

#include <stdio.h>
#include <stdlib.h>

int rand = 10;
int main()
{
    // 编译报错：error C2365: "rand": 重定义；以前的定义是"函数"
    printf("%d\n", rand);
    return 0;
}

2 - 2 · namespace的定义

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

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

C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找⼀个变量/函数/类型出处(声明或定义)的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期。
namespace只能定义在全局，当然他还可以嵌套定义。
项目工程中多文件中定义的同名namespace会认为是⼀个namespace，不会冲突。
C++标准库都放在一个叫std(standard)的命名空间中。

2 - 3 · 命名空间的使用

编译查找⼀个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间里面去查找。所以我们要使用命名空间中定义的变量/函数，有三种方式：

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

因此，如果我们这样写是会报错的：

复制代码

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

int main()
{
    // 编译报错：error C2065: "a": 未声明的标识符
    printf("%d\n", a);
    return 0;
}

1.指定命名空间，需要用到域作用限定符 :: ，如下：

复制代码

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

2.使用using展开某个成员：

复制代码

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

3.使用using展开命名空间所有成员：

复制代码

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

3 · 输入 / 输出

<iostream> 是 Input Output Stream 的缩写，是标准的输入、输出流库，定义了标准的输入、输出对象。
std::cin 是 istream 类的对象，它主要面向窄字符（narrow characters (of type char)）的标准输入流。
std::cout 是 ostream 类的对象，它主要面向窄字符的标准输出流。
std::endl 是一个函数，流插入输出时，相当于插入⼀个换行字符加刷新缓冲区。
<<是流插入运算符，>>是流提取运算符。（C语言还用这两个运算符做位运算左移/右移）
使用C++输入输出更方便，不需要像printf/scanf输入输出那样，需要手动指定格式，C++的输入输出可以自动识别变量类型(本质是通过函数重载实现的)，其实最重要的是C++的流能更好的支持自定义类型对象的输入输出。
cout/cin/endl等都属于C++标准库，C++标准库都放在⼀个叫std(standard)的命名空间中，所以要通过命名空间的使用方式去用他们。
8.
在vs系列编译器中，没有包含<stdio.h>，也可以使用printf和scanf，因为在包含<iostream>间接包含了。其他编译器可能会报错。

3 - 1 · C++的第一个程序

用C++自己一套的输入输出打印一个hello world：

复制代码

#include <iostream>
using namespace std;

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

运行一下：

4 · 缺省参数

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

#include
using namespace std;

void Func(int x = 10)
{
cout << x << endl;
}

int main()
{
Func();
Func(2);
return 0;
}

运行一下：

没有传参时，用的是默认值，传了参用的是传参值。

5 · 函数重载

C++支持在同⼀作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。这样C++函数调用就表现出了多态行为，使用更灵活。C语言是不支持同⼀作用域中出现同名函数的。

5 - 1 · 构成函数重载的条件

5 - 1 - 1 · 参数类型不同

复制代码

#include <iostream>
using namespace std;

int Add(int x, int y)
{
	cout << "Add-int" << endl;

	return x + y;
}

double Add(double x, double y)
{
	cout << "Add-double" << endl;

	return x + y;
}

int main()
{
	Add(1, 2);
	Add(1.1, 2.2);
	return 0;
}

运行一下：

5 - 1 - 2 · 参数个数不同

复制代码

#include <iostream>
using namespace std;

void Func()
{
	cout << "Func()" << endl;
}

void Func(int x)
{
	cout << "Func(int)" << endl;
}

int main()
{
	Func();
	Func(1);
	return 0;
}

运行一下：

5 - 1 - 3 · 参数顺序不同

复制代码

#include <iostream>
using namespace std;

void Func(int x, double y)
{
	cout << "Func(int, double)" << endl;
}

void Func(double x, int y)
{
	cout << "Func(double, int)" << endl;
}

int main()
{
	Func(1, 1.1);
	Func(2.2, 2);
	return 0;
}

运行一下：

5 - 2 · 会出问题的写法

1.仅仅只有返回值不同不能作为重载条件，因为调用时无法区分比如：

复制代码

void Func()
{
    //...
}

int Func()
{
    //...
}

2.下面这两个函数构成函数重载，但是调用 f()时会保错，存在歧义，编译器不知道要调用谁：

复制代码

void f1()
{
    cout << "f()" << endl;
}

void f1(int a = 10)
{
    cout << "f(int a)" << endl;
}

6 · 引用

6 - 1 · 引用的概念

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

复制代码

int a = 0;

// 引⽤：b和c是a的别名
int& b = a;
int& c = a;
// 也可以给别名b取别名，d相当于还是a的别名
int& d = b;

6 - 2 · 引用的特性

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

// 编译报错："ra": 必须初始化引⽤
int& ra;

6 - 3 · 引用的使用

引用在实践中主要是用于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被引用对象。
引用传参跟指针传参功能是类似的，引用传参相对更方便⼀些。
引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引用跟其他语言的引用(如Java)是有很大的区别的，除了用法，最大的区别，C++引用定义后不能改变指向，Java的引用可以改变指向。

void Swap(int& rx, int& ry)
{
int tmp = rx;
rx = ry;
ry = tmp;
}

int main()
{
int x = 10, y = 20;
cout << x <<" " << y << endl;
Swap(x, y);
cout << x << " " << y << endl;
return 0;
}

运行一下：

6 - 4 · const引用

可以引用⼀个const对象，但是必须用const引用。const引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但是不能放大。
需要注意的是涉及运算以及类型转换等类似场景，比如 int& rb = a*3 或者 double d = 1.1 int& rd = d，这种情况下 a*3 的结果是保存在一个临时对象中的，类型转换也是如此，会产生一个临时对象存储中间值，此时rb 和 rd 引用的都是临时对象，而C++规定临时对象具有常性，所以这里就触发了权限放大，必须要用 const引用才可以。
所谓临时对象就是编译器需要⼀个空间暂存表达式的求值结果时临时创建的⼀个未命名的对象，C++中把这个未命名对象叫做临时对象。

6 - 5 · 指针和引用的关系

C++中指针和引用就像两个性格迥异的亲兄弟，在实践中他们相辅相成，功能有重叠性，但是各有自己的特点，互相不可替代。

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

7 · inline

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

8 · 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(int x)，因此与程序的初衷相悖。f((void*)NULL); 调用会报错。
C++11中引⼊nullptr，nullptr是⼀个特殊的关键字，nullptr是⼀种特殊类型的字⾯量，它可以转换成任意其他类型的指针类型。使⽤nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被隐式地转换为指针类型，而不能被转换为整数类型。

以上内容如有错误或不准确之处，欢迎指出，或者你有更好的想法，也欢迎交流。