0
点赞
收藏
分享

微信扫一扫

请回答C++-入门C++

请回答C++-初识C++

OIP-C

在学习过C语言初阶和C语言进阶之后,开始正式学习C++,本文主要涉及C++入门引入的内容是C++的关键字、命名空间、缺省参数、IO、函数重载、内联函数、auto关键字、新型for循环、nullptr、引用为面向对象打好基础

image-20220126145932252

1. 关键字

在关键字中,C++对c语言内容进行了添加和补充,C++对比C新增了31个关键字,达到了63个

下面是所有的关键字,在这里暂时混个眼熟即可未来有了一定基础再尝试理解和使用

image-20220124114054008

2. 命名空间

2.1 认识命名空间

比如namespace 定义的是一个域,为了避免命名冲突和命名污染问题
C语言的库里面,有两个函数用scanf和strlen名称
假设我的代码里面想用这个两个名称命名变量

int main()
{
	int scanf = 10;
	int strlen = 20;
	// C语言解决不了冲突的问题
	scanf("%d", &scanf);
	printf("%d\n", scanf);
	printf("%d\n", strlen);
	return 0;
}

这样就跑不过去
C++可以解决这个问题
通过创建一个命名空间,同时利用::这样一个域作用符来实现名字的隔离,比如下面可以了

namespace allen
{
	int scanf=10;
	int strlen=20;
}
int main()
{
	// Cpp解决冲突
        printf("%x\n", scanf);
	printf("%x\n", strlen);
	scanf("%d", &allen::scanf); 
	printf("%d\n",allen::scanf);
	printf("%d\n",allen::strlen);
	return 0;
}

2.2 命名空间的特点

⚡️普通定义

namespace allen
{
	int scanf=10;
	int strlen=20;
}

⚡️命名空间的嵌套

	namespace allen
{
	int scanf = 10;
	int strlen = 20;
	int Add(int left, int right)
	{
		return left + right;
	}
	namespace n1
	{
		int c;
				int d;
				int Sub(int left, int right)
				{
					return left - right;
				}	
				// 还可以再套
	}
}
int main()	
{
	allen::n1::Sub(10, 4);    
         return 0;
}

⚡️如果同一个工程中有多个名称相同的命名空间,最后编译器将其汇合成一个命名空间中

⚡️同一个域中当然也不能同名

2.3 使用命名空间

首先了解:C++库为了防止命名冲突,把自己库里面的东西都定义在一个std的命名空间中

要使用标准库中的东西,有三种方式

⚡️指定命名空间

	std::cout << "hello world" << std::endl;
	std::vector<int> v;
	std::string s;

⚡️把std整个展开,相当于库里面的东西都到全局域了

namespace allen
{
	int a = 20;
	int b = 10;
}

using namespace allen;//关键字using的使用将命名空间展开到全局

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

⚡️对部分常用的库里面的东西展开

using std::cout;
using std::endl;

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

	return 0;
}

最后再举一个例子熟悉一下

	int a = 0;

	int main()
{
	int a = 1;
	printf("%d\n", a);
	printf("%d\n", ::a);//空白表示全局域
	return 0;
}

3. I/O输入和输出

3.1 头文件与输入输出函数快速入门

🐉使用cout标准输出(控制台)和cin标准输出(控制台)时,必须包含头文件以及std标准命名空间。cpp中输出输入流的头文件是<iostream>

🐉下面给出三个输入输出有关的三个函数

⚡️ostream 类型全局对象 cout

⚡️istream 类型全局对象 cin

⚡️ 全局的换行符号 endl

🐉cin的输入格式为cin >> 变量名,cout输出格式cout << 变量名

使用示例

	int a = 10;
	char str[10];
	std::cin >> a;
	std::cin >> str;
	std::cout << a << str << std::endl;

image-20220121163153963

4. 缺省参数

4.1缺省参数的定义

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

// 缺省参数
void TestFunc(int a = 0)
{
	cout << a << endl;
}

int main()
{
	TestFunc(10);
	TestFunc();

	return 0;
}

比如说这里的TestFunc,当传入10的时候就是输出10,否则不传输出0

4.2 缺省参数的分类

4.2.1全缺省参数

// 全缺省
void TestFunc(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}
int main()
{
	TestFunc(1, 2, 3);
	TestFunc();
	TestFunc(1);
	TestFunc(1,2);
	return 0;
}

image-20220121214607853

4.2.2 半缺省参数

 半缺省
void TestFunc(int a, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}
// 缺省参数的作用是什么,调用更灵活
int main()
{
	TestFunc(1);
	TestFunc(1, 2);
	TestFunc(1, 2, 3);
	return 0;
}

image-20220121214733539

🍁将函数中的部分参数设置为缺省参数

4.3 实际应用

实际开发中,什么时候会用到缺省参数呢?

这是C语言所做不到的,C++提供的特殊的功能,如果我知道要存多少数据,直接改就可以了,但是如果不知道的话,那就按照默认值

4.4 缺省参数注意事项

5. 函数重载

5.1 重载快速入门

和Java中的重载是差不多的意思,C++也可以定义同名的函数

🌰

int Add(int left, int right)
{
	return left + right;
}

int Add(int left = 10, int right = 20)//缺省参数不是重载,如果写了这个会报错
{
	return left + right;
}

char Add(char left, char right)
{
	return left + right;
}

double Add(double left, double right)
{
	return left + right;
}
int main()
{
	cout << Add() << endl;//如果不把第一个Add注释掉,就会报错
	cout << Add(1, 2) << endl;  // 字面量  给的整形默认算常量
	cout << Add('1', '2') << endl;
	cout << Add(1.1, 2.2) << endl;
	return 0;
}

🌰🌰

void f(int a, int b, int c = 1)
{}

void f(int a, int b)
{}

int main()
{
	f(1, 2, 3);
	// f(1, 2);//err产生了二义性
	return 0;
}

🌰🌰🌰

void swap(int* a, int* b)
{
	// ...
}
void swap(double* a, double* b)
{
	// ...
}
int main()
{
	int x = 0, y = 1;
	swap(&x, &y);
	double m = 1.1, n = 2.2;
	swap(&m, &n);
	return 0;
}

⚠️ 注意:返回值不同不构成重载,比如下面的

short Add(short left, short right)
{
return left+right;
}
int Add(short left, short right)
{
return left+right;
}

5.1 名字修饰

此时我们对函数重载提出了疑问

5.1.1为什么C语言不支持重载,C++是怎么实现的

要解决这些个问题需要Linux来辅助演示

⚡️ Linux修饰规则

首先我们知道在C/C++中,一个程序要运行起来,需要经历以下几个阶段:预处理、编译、汇编、链接。

image-20220124172938032

image-20220124173514615

🍁 实际我们的项目通常是由多个头文件和多个源文件构成,而通过编译链接,我们可以知道,【当前a.cpp中调用了b.cpp中定义的Add函数时】,编译后链接前,a.o的目标文件中没有Add的函数地址,因为Add是在b.cpp中定义的,所以Add的地址在b.o中。那么怎么办呢?
🍁 所以链接阶段就是专门处理这种问题,链接器看到a.o调用Add,但是没有Add的地址,就会到b.o的符号表中找Add的地址,然后链接到一起。
🍁 那么链接时,面对Add函数,连接器会使用哪个名字去找呢?这里每个编译器都有自己的函数名修饰规
则。
🍁 由于Windows下vs的修饰规则过于复杂,而Linux下gcc的修饰规则简单易懂
🍁 通过下面我们可以看出gcc的函数修饰后名字不变。而g++的函数修饰后变成【_Z+函数长度+函数名+类型首字母】。

简单点说的话就是在函数链接的时候,重载的函数的地址和命名是不同的,所以区分了同名函数

⚡️Windows修饰规则

对比Linux的修饰规则,Windows的则会复杂很多,变换更多

image-20220124195842096

还可以参考如下网站学习函数调用约定和名字修饰规则

C++函数重载
C/C++的调用约定

🍁 通过这里就理解了C语言没办法支持重载,因为同名函数没办法区分。而C++是通过函数修饰规则来区分,只要参数不同,修饰出来的名字就不一样,就支持了重载。

🍁 另外我们也理解了,为什么函数重载要求参数不同,而跟返回值没关系。

5.1.2 extern "C"的作用是什么

有时候在C++工程中可能需要将某些函数按照C的风格来编译,在函数前加extern “C”,意思是告诉编译器,将该函数按照C语言规则来编译。

image-20220124205240715

6. 引用

C++中,新引入的引用和指针互相是对标的

6.1 引入的概念

⚡️我们把a改变了值,b也会相应的改变

⚡️同时两个值的地址也是一样的

如何使用引用呢?

int main()
{
	int a = 10;
	// b是a的引用(别名)
	int& b = a;
	b = 20;
	int& c = b;
	c = 30;
	return 0;
}

🍁别名是可以套娃取的

6.2 引用的功能

void swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void swap(int& r1, int& r2)
{
	int tmp = r1;
	r1 = r2;
	r2 = tmp;
}
int main()
{
	int a = 1, b = 2;
	swap(&a, &b);
	swap(a, b);
	return 0;
}

引用简化了指针的效果,可以说很好用

struct Stack
{
	int* a;
	int size;
	int capacity;
};
void StackInit(struct Stack* ps)
{}
void StackInit(struct Stack& s)
{}
int main()
{
	struct Stack st;
	StackInit(&st);
	StackInit(st);
	return 0;
}

有时候引用简化了使用二级指针

6.3 引用特点

🍁 引用在定义时必须初始化
🍁 一个变量可以有多个引用
🍁 引用一旦引用一个实体,再不能引用其他实体
🍁 引用类型必须和引用实体是同种类型的

double d = 12.34;
int& rd = d; // 该语句编译时会出错,类型不同

🍁 常引用不能放大权限,常变量的引用也得是常引用

const int a = 10;
//int& ra = a; // 该语句编译时会出错,a为常量
const int& ra = a;//应该如此

🍁 常引用权限可以缩小,但是不可以放大

int& b = 10; // 
const int& b = 10;//缩小权限是可以接受的
const int& rd = d;
}

🍁 在c中有一个隐式类型转换,现在有一个奇特的语法,const之后可以“隐式转换”引用类型

	int c = 10;
	double d = 1.11;
	d = c; // 隐式类型转换
	
	int c = 10;
	double& rc = c;//err
	const double& rc = c;//pass

原因是这样的,语法层的理解是:在隐式类型转换的时候,int c会产生一个double类型的临时变量,且这个临时变量具有常性,所以加一个const就可以了

6.4 引用场景快速入门

6.4.1 做参数

比如Swap函数

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

6.4.2 返回值

传值返回,返回的对象的临时拷贝

传引用返回,返回的是对象的引用

🌸传值返回

int Add(int a, int b)
{
	int c = a + b;
	return c;
}

int main()
{
	const int& ret = Add(1, 2);
	return 0;
}

如果返回值用传值法返回int的话,由于是临时变量,是一个具体的空间,且具有常性,所以要加const

🌸传引用返回

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

感觉好像没有问题其实有问题,因为Add函数相当出了函数栈帧,栈帧就销毁,那么这块空间相当于已经不属于这个赋引用值的ret了,也就是说,如果此时再要访问,虽然空间暂时没有被销毁,但是已经是越界访问了,结果是不确定的,就好像酒驾,不报错不代表没有问题

有时会输出随机值,比如

int& Add(int a, int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	Add(5, 7);
	cout << ret << endl;
	printf("hello world\n");
	cout << ret << endl;
	return 0;
}

image-20220125095843322

因此一般的代码是不能够用引用返回的

那么什么时候可以利用呢?把属性变成静态的就可以了,这样的话不会被销毁

int& Add(int a, int b)
{
	static int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	Add(5, 7);
	printf("hello world\n");
	cout << ret << endl;
	return 0;
}

image-20220125100211234

6.5 传值、传引用效率比较

不是说传引用返回一无是处,还是有优点的

先看看传引用作为参数的情况

#include <time.h>
#include<iostream>
using namespace std;
struct A{ int a[10000]; };
void TestFunc1(A a){}
void TestFunc2(A& a){}
void TestRefAndValue()
{
	A aa;
	// 以值作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 10000; ++i){
		TestFunc1(aa);
    }
	size_t end1 = clock();
	// 以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 10000; ++i){
        		TestFunc2(aa);
    }
	size_t end2 = clock();
	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
int main()
{
	TestRefAndValue();
 }

image-20220125101336027

再看看返回值的情况

#include <time.h>
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
	// 以值作为函数的返回值类型
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1();
	size_t end1 = clock();
	// 以引用作为函数的返回值类型
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2();
	size_t end2 = clock();
	// 计算两个函数运算完成之后的时间
	cout << "TestFunc1 time:" << end1 - begin1 << endl;
	cout << "TestFunc2 time:" << end2 - begin2 << endl;
}
int main()
{
	TestReturnByRefOrValue();
 }

image-20220125101755452

6.6 指针VS引用

语法概念上引用就是一个别名,没有独立空间,和其引用实体共用同一块空间。

	// 在语法上,这里给a这块空间取了一个别名,没有新开空间
	int& ra = a;
	ra = 20;
	// 在语法上,这里定义个pa指针变量,开了4个字节,存储a的地址
	int* pa = &a;
	*pa = 20;

底层实现上实际是有空间的,因为引用是按照指针方式来实现的。

引用和指针的汇编代码对比,其实底层很像,区别只在换了个别名

image-20220126100122486

6.6.1 引用和指针的不同点:

🍁 引用概念上定义一个变量的别名,种子很存储一个变量的地址
🍁 引用在定义时必须初始化,指针没有要求
🍁 引用在初始化时引用一个实体后,就不能再引用其他实体,而指针可以在任何时候指向任何一个同类型实体
🍁 不能直接NULL引用,但有NULL指针

int* p = NULL;
int*& rp = p;
	cout << rp << endl;

🍁 在sizeof中含义不同引用结果为引用类型的大小,但指针始终是地址空间所占字节个数(32位平台下占4个字节)
🍁 引用自加即引用的实体增加1,指针自加即指针向后偏移一个类型的大小
🍁 有多级指针,但是没有多级引用
🍁 访问实体方式不同,指针需要显式解引用,引用编译器自己处理
🍁 引用比指针使用起来相对更安全

下面我们混合一下指针和引用,来看看下面一段代码的意思

	int* pa = &a;
	*pa = 20;

	int b = 10;
	int*& rpa = pa;
	rpa = &b;

7. 内联函数

7.0 Intro of inline

inline修饰的函数叫做内联函数,编译时C++编译器会在调用内联函数的地方展开,而不是开一个函数栈帧,函数栈帧是大开销,而如果没有函数压栈的开销,内联函数就可以提升程序运行的效率。

C++推荐频繁调用的小函数,定义成inline,会在调用的地方展开,没有栈帧开销

7.1 宏函数的优缺点即内联函数的优点

😄 优点

🛡 增强代码的复用性。
🛡 提高性能。

😢 缺点

🗡预处理阶段展开,无法调试

🗡宏的语法复杂,容易出错

🗡没有类型安全的检查

###🌰写一个Add的宏函数

注意还是比较容易写错的

// #define ADD(int x, int y) return x + y 典型的错误写法
// #define ADD(x, y) x+y;// 不能带分号 err
// #define ADD(x, y) (x)+(y) //err
#define ADD(x, y) ((x)+(y))

那么C语言宏函数的缺点就是C++内联函数的优点

C++有哪些技术替代宏?

  1. 常量定义 换用const
  2. 函数定义 换用内联函数

7.2 内联函数快速入门

凡是在汇编中看到有call的一般就是要开辟函数栈帧,不内联的函数就是含call的

image-20220126123613796

怎么样才能看到内联函数具体的汇编呢,想要把debug改成release版,因为debug版本为了方便调试,没有展开内联函数,可以看到内联函数确实没有call,即开一个函数栈帧

image-20220126124858016

但是下面的情况还是会产生影响,来看一下

image-20220126132909313

指令多代表效率低吗,不是这样的,指令多,但是不用开栈帧,所以还是快,问题在于内联是在用空间换时间,当然编译器也是有底线的,函数太大不会让你内联的

7.3 内联函数特点

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

8. auto关键字

8.0 Intro of auto

使用auto定义变量时必须对其进行初始化,在编译阶段编译器需要根据初始化表达式来推导auto的实际类
型。因此auto并非是一种“类型”的声明,而是一个类型声明时的“占位符”,编译器在编译期会将auto替换为
变量实际的类型。

8.1 auto快速入门

🍁 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;
}

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

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

8.2 auto不能推导的类型

🍁 auto不能作为函数的参数

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

🍁 auto不能直接用来声明数组

void TestAuto()
{
int a[] = {1,2,3};
auto b[] = {456};
}

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

9 新型for循环

9.1 范围for的语法

新for循环,和Java的foreach增强for循环很像

int main()
{
	for (auto& e : array)
	{
		e *= 2;
	}
	for (auto ee : array)
	{
		cout << ee << " ";
	}
	cout << endl;
	return 0;
}

9.2 范围for的使用条件

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

void TestFor(int array[])//没给范围不可以,err
{//传进来的已经变成指针了
	for(auto& e : array)
	cout<< e <<endl;
}

🍁 迭代的对象要实现++和==的操作。

int main()
{
	int array[] = { 1, 2, 3, 4, 5 };
	// 范围for C++11新语法遍历,更简单,数组都可以
	// 自动遍历,依次取出array中的元素,赋值给e,直到结束
	for (auto e : array)
	{
		e *= 2;
	}
	for (auto ee : array)
	{
		cout << ee << " ";
	}
	cout << endl;
	return 0;
}

10. 指针空值nullptr(C++11)

10.1 nullptr快速入门

在良好的C/C++编程习惯中,声明一个变量时最好给该变量一个合适的初始值,否则可能会出现不可预料的
错误,比如未初始化的指针。如果一个指针没有合法的指向,我们基本都是按照如下方式对其进行初始化:

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

#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif

可以看到,NULL可能被定义为字面常量0,或者被定义为无类型指针(void*)的常量。不论采取何种定义,在
使用空值的指针时,都不可避免的会遇到一些麻烦

NULL会被认为是一个int,而只有nullptr才是会被看做一个指针

void f(int i)
{
	cout << "f(int)" << endl;
}
void f(int* p)
{
	cout << "f(int*)" << endl; 
}
int main()
{
	int* p1 = NULL; //  int* p1 = 0; 
	int* p2 = nullptr;
	f(0);
	f(NULL);
	f(nullptr);
	return 0;
}

image-20220126144942954

10.2 nullptr注意事项

🍁 在使用nullptr表示指针空值时,不需要包含头文件,因为nullptr是C++11作为新关键字引入的。

🍁 在C++11中,sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。

🍁 为了提高代码的健壮性,在后续表示指针空值时建议最好使用nullptr。

举报

相关推荐

0 条评论