C++入门基础

发布于：2025-06-26 ⋅ 阅读:(16) ⋅ 点赞:(0)

C++入门基础

一、C++关键字

C++共计63个关键字，其中圈主的32个是C语言共有的：
在这里插入图片描述

二、命名空间

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

1、命名空间的定义

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

2、命名空间的使用

C++为了防止命名冲突，把自己库里面的东西都定义在一个std的命名空间中要使用标准库里面的东西，有三种方式

  • 指定命名空间–麻烦，每个地方都要指定，但也是最规范的方式
int c = 100;
namespace N
{
	int a = 10;
	int b = 20;
	int Add(int left, int right)
	{
		return left + right;
	}
	int Sub(int left, int right)
	{
		return left - right;
	}
}
  • 把std整个展开，相当于库里面的东西全部到全局域里面去了，使用起来方便但是可能会有与自己命名空间定义的冲突，规范工程中不推荐这种，日常练习可以用这种。
using namespace std;
  • 对部分常用的库里面的东西展开->针对1和2的折中方案，项目中也经常使用
using std::cout;
using std::endl;
int main()
{
	printf("%d\n", N::a);
	printf("%d\n", N::b);
	printf("%d\n", N::Add(1, 2));
	printf("%d\n", N::Sub(1, 2));
	int c = 10;
	printf("%d\n", c);   //局部变量优先，所以c为10
	printf("%d\n", ::c); //指定访问左边域，空白表示全局域
}

三、C++输入与输出

  1. 使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含**< iostream >头文件以及std标准命名空间**。
    注意：早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此推荐使用+std的方式。
  2. 使用C++输入输出更方便，不需增加数据格式控制，比如：整形–%d，字符–%c。
  3. ostream 类型全局对象，istream 类型全局对象 ，endl全局的换行符号。
struct Person
{
	char name[10];
	int age;
};
int main()
{
	std::cout << "bit education ";
	std::cout << "bit education" << std::endl;
	//cout与cin对比C语言printf\scanf 来说可以自动识别类型(函数重载+运算符重载)
	int a = 10;
	int* p = &a;
	printf("%d,%p\n", a, p);
	std::cout << a << "," << p << std::endl;
	std::cin >> a;
	printf("%d\n", a);
	char str[100];
	std::cin >> str;  //cin不用&,因为引用
	std::cout << str << std::endl;
	
	struct Person P = { "uzi", 23 };  //格式化输出printf比cout好
	printf("name:%s age:%d\n", P.name, P.age);
	std::cout << "name:" << P.name<<" age:"<< P.age << "\n";
}

四、缺省参数

1、缺省参数的概念

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

#include <iostream>
using namespace std;
void Print(int a = 0)
{
	cout << a << endl;
}
int main()
{
	Print();//没有指定实参，使用参数的默认值（打印0）
	Print(10);//指定了实参，使用指定的实参（打印10）
	return 0;
}

2、缺省参数的分类

1）、全缺省参数

全缺省参数，即函数的全部形参都设置为缺省参数。

void testFunc2(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

2）、半缺省参数

半缺省参数，即函数的参数不全为缺省参数。

void testFunc3(int a, int b = 10, int c = 20)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

注意事项

  1. 半缺省参数必须从右往左依次来给出，不能间隔着给。
//错误示例
void Print(int a, int b = 20, int c)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}
  1. 缺省参数不能在函数声明和定义中同时出现。
//错误示例
//test.h
void Print(int a, int b, int c = 30);
//test.c
void Print(int a, int b, int c = 30)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}
  1. 缺省值必须是常量或者全局变量。
//正确示例
int x = 30;//全局变量
void Print(int a, int b = 20, int c = x)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}
  1. C语言不支持（编译器不支持）。

五、函数重载

1、函数重载的概念

函数重载:是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同，常用来处理实现功能类似数据类型不同的问题。

#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()
{
	cout << Add(1, 2) << endl;//打印1+2的结果
	cout << Add(1.1, 2.2) << endl;//打印1.1+2.2的结果
	return 0;
}

注意：形参列表不同是指参数个数、参数类型或者参数顺序不同，若仅仅是返回类型不同，则不能构成重载。

2、函数重载的原理

为什么C++支持函数重载，而C语言不支持函数重载呢？在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。
在这里插入图片描述

  • 组成一个程序的每个源文件通过编译过程分别转换成目标代码（object code）。

  • 每个目标文件由链接器（linker）捆绑在一起，形成一个单一而完整的可执行程序。

  • 链接器同时也会引入标准C函数库中任何被该程序所用到的函数，而且它可以搜索程 序员个人的程序库，将其需要的函数也链接到程序中。

    在C++中调用Add函数

    在这里插入图片描述

    在C中调用Add函数

    在这里插入图片描述

  • C语言不能支持重载，是因为同名函数没办法区分。而C++是通过函数修饰规则来区分的，只要函数的形参列表不同，修饰出来的名字就不一样，也就支持了重载。

  • 另外我们也理解了，为什么函数重载要求参数不同，和返回值没关系。

3、extern"C"的作用

有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern “C”，意思是告诉编译器，将该函数按照C语言规则来编译，所以这个函数不能进行重载。

extern "C" int Add(int left, int right);
int main()
{
	Add(1, 2);
	return 0;
}

六、C++引用

1、引用的概念

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

  • 其使用的基本形式为：类型& 引用变量名(对象名) = 引用实体
#include <iostream>
using namespace std;
int main()
{
	int a = 10;
	int& b = a;//给变量a去了一个别名，叫b
	cout << "a = " << a << endl;//a打印结果为10
	cout << "b = " << b << endl;//b打印结果也是10
	b = 20;//改变b也就是改变了a
	cout << "a = " << a << endl;//a打印结果为20
	cout << "b = " << b << endl;//b打印结果也是为20
	return 0;
}

2、引用的特性

  1. 引用在定义时必须初始化
	int a = 10;
	int& b = a;
//错误示例
	int a = 10;
	int&b;
	b = c;
  1. 一个变量可以有多个引用
int a = 10;
int& b = a;
int& c = a;
int& d = a;
  1. 引用一旦引用了一个实体，就不能再引用其他实体

3、常引用

引用类型必须和引用实体是同种类型的。但是仅仅是同种类型，还不能保证能够引用成功，我们若用一个普通引用类型去引用其对应的类型，但该类型被const所修饰，那么引用将不会成功。

权限不能放大，但是可以缩小

void TestConstRef()
{
	//常引用是创建一个临时变量，引用名是临时变量的引用
	const int a = 10;
	//int& ra = a; // 该语句编译时会出错，a为常量,而且a为不可以修改
	const int& ra = a;
	// int& b = 10; // 该语句编译时会出错，b为常量
	const int& b = 10;
	double d = 12.34;
	//int& rd = d; // 该语句编译时会出错，类型不同
	const int& rd = d;
}
  • 临时空间的别名
int c=10;
double d=1.11;
const double& rc=c;//rc就为临时空间的别名，隐藏了类型的转换

4、引用的使用场景

  1. 做参数
void Swap2(int& a, int& b) //通过引用来交换
{
	int tmp = a;
	a = b;
	b = tmp;
}
void Swap1(int* a, int *b) //通过指针来交换
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
  1. 做返回值
    特别注意，我们返回的数据不能是函数内部创建的普通局部变量，因为在函数内部定义的普通的局部变量会随着函数调用的结束而被销毁。我们返回的数据必须是被static修饰或者是动态开辟的或者是全局变量等不会随着函数调用的结束而被销毁的数据。
int& Add(int a, int b)
{
	static int c = a + b;
	return c;
}

5、传值、传引用的效率

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

6、引用与指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间，在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

1）、汇编分析

int main()
{
	int a = 10;
	//在语法上，这里给a这块空间取了一个别名，没有新开空间
	int& ra = a;
	ra = 20;

	//在语法上，这里定义了一个pa指针，开辟了4个字节（32位平台）的空间，用于存储a的地址
	int* pa = &a;
	*pa = 20;
	return 0;
}

引用汇编分析

在这里插入图片描述
关键点：

  • lea rax, [a]，lea（Load Effective Address）计算 a 的地址，但 不访问内存，只是计算地址。这里 rax 存储的是 a 的地址。

  • mov qword ptr [ra], rax这里 ra 是引用变量，但 它本身仍然是一个变量（存储的是 a 的地址）。在底层，引用仍然占用空间（这里 ra 占用 8 字节，因为 x64 平台指针是 64 位）。

  • ra = 20 的汇编先读取 ra 存储的地址（即 a 的地址），然后直接修改 a 的值。引用没有额外的解引用操作（*），但底层仍然是通过地址访问。

    指针的汇编分析

在这里插入图片描述
关键点：

  • lea rax, [a]，和引用一样，先计算 a 的地址。

  • mov qword ptr [pa], rax把 a 的地址存入 pa 指针变量。指针和引用在存储地址的方式上完全一致（都占用 8 字节）。

  • *pa = 20 的汇编和引用一样，先读取 pa 存储的地址，再修改目标内存。指针和引用在访问方式上完全一致。

2）、重要点

  • 引用在定义时必须初始化，指针没有要求。
  • 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
  • 没有NULL引用，但有NULL指针。
  • 在sizeof中的含义不同：引用的结果为引用类型的大小，但指针始终是地址空间所占字节个数（32位平台下占4个字节）。
  • 引用进行自增操作就相当于实体增加1，而指针进行自增操作是指针向后偏移一个类型的大小。
  • 有多级指针，但是没有多级引用。
  • 访问实体的方式不同，指针需要显示解引用，而引用是编译器自己处理。
  • 引用比指针使用起来相对更安全。

七、内联函数

1、内联函数的概念

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

2、内联函数的特性

int Add(int a, int b)
{
	return a + b;
}
int main()
{
	int ret = Add(1, 2);

	return 0;
}

在这里插入图片描述

  1. nline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
  2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
  3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

八、auto关键字

1、auto关键字

  • 在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它，大家可思考下为什么？
  • C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

2、auto关键字使用方法

int main()
{
	int x = 10;
	auto a = &x;  // int* 
	auto* b = &x; // int*
	int& y = x;   // y的类型是什么？int
	auto c = y;  // int 
	auto& d = x; // d的类型是int， 但是这里指定了d是x的引用
	// 打印变量的类型
	cout << typeid(x).name() << endl;
	cout << typeid(y).name() << endl;
	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	return 0;
}

在这里插入图片描述
1）、auto与指针和引用结合起来使用，用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
2）、在同一行定义多个变量当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

3、auto关键字不能使用场景

1）、不能作为函数的参数

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

2）、不能直接用来声明数组

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

3）、为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
4）、auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还lambda表达式等进行配合使用。

九、基于范围的for循环(C++11)

1、范围for的语法

1）、若是在C++98中我们要遍历一个数组，可以按照以下方式：

int main()
{
	int array[] = { 1, 2, 3, 4, 5 };
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
	{
		cout << array[i] << " ";
	}
	cout << endl;
}
	return 0;
}

2）、对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	//将数组元素值全部乘以2
	for (auto& e : arr)
	{
		e *= 2;
	}
	//打印数组中的所有元素
	for (auto e : arr)
	{
		cout << e << " ";
	}
	cout << endl;

2、范围for的使用条件

注意：与普通循环类似，可用continue来结束本次循环，也可以用break来跳出整个循环。

1）、for循环迭代的范围必须是确定的，对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。

2）、迭代的对象要实现++和==的操作

十、指针空值nullptr

1、C++98中的指针空值

初始化方式

int* p1 = NULL;
int* p2 = 0;

NULL其实是一个宏，在传统的C头文件(stddef.h)中可以看到如下代码：

/* Define NULL pointer value */
#ifndef NULL
#ifdef __cplusplus
#define NULL    0
#else  /* __cplusplus */
#define NULL    ((void *)0)
#endif  /* __cplusplus */
#endif  /* NULL */

NULL可能被定义为字面常量0，也可能被定义为无类型指针(void*)的常量。但是不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，例如：

#include <iostream>
using namespace std;
void Fun(int p)
{
	cout << "Fun(int)" << endl;
}
void Fun(int* p)
{
	cout << "Fun(int*)" << endl;
}
int main()
{
	Fun(0);           //打印结果为 Fun(int)
	Fun(NULL);        //打印结果为 Fun(int)
	Fun((int*)NULL);  //打印结果为 Fun(int*)
	return 0;
}

程序本意本意是想通过Fun(NULL)调用指针版本的Fun(int* p)函数，但是由于NULL被定义为0，Fun(NULL)最终调用的是Fun(int p)函数。

注：在C++98中字面常量0，既可以是一个整型数字，也可以是无类型的指针(void*)常量，但编译器默认情况下将其看成是一个整型常量，如果要将其按照指针方式来使用，必须对其进行强制转换。

2、C++11中的指针空值

对于C++98中的问题，C++11引入了关键字nullptr。

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

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布