【C++】入门基础知识概括


秃头侠们好呀,今天咱们来聊聊 C++入门基础

本章重点

  1. C++关键字
  2. 命名空间
  3. C++输入 输出
  4. 缺省参数
  5. 函数重载
  6. 引用
  7. 内联函数
  8. auto关键字
  9. 基于范围的for循环
  10. 空指针nullptr

C++关键字

C++总计63个关键字,C语言32个关键字

C++关键字如下
在这里插入图片描述这里就不一一讲解了,后续文章都会逐个提到。

命名空间

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

命名空间定义

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

//1. 普通的命名空间
namespace N1 // N1为命名空间的名称
{
	// 命名空间中的内容,既可以定义变量,也可以定义函数
	int a;
	int Add(int left, int right)
	{
		return left + right;
	}
}
//2. 命名空间可以嵌套
namespace N2
{
	int a;
	int b;
	int Add(int left, int right)
	{
		return left + right;
	}
	namespace N3
	{
		int c;
		int d;
		int Sub(int left, int right)
		{
			return left - right;
		}
	}
}
//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
namespace N1
{
	int Mul(int left, int right)
	{
		return left * right;
	}
}

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

命名空间使用

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;
	}
}
int main()
{
	printf("%d\n", a); // 该语句编译出错,无法识别a
	return 0;
}

命名空间的使用有三种方式:

  • 加命名空间名称及作用域限定符
    (指定作用域,做到了最好的隔离,但使用不方便)
int main()
{
printf("%d\n", N::a);
return 0;
}
  • 使用using将命名空间中成员引入
    (用于展开命名空间中常用的,此种方法较为推荐)
using N::b;
int main()
{
printf("%d\n", N::a);
printf("%d\n", b);
return 0;
}
  • 使用using namespace 命名空间名称引入
    (这种方法是直接展开N,用起来方便,但失去了隔离的效果)
using namespce N;
int main()
{
printf("%d\n", N::a);
printf("%d\n", b);
Add(10, 20);
return 0;
}

C++输入&输出

#include<iostream>
using namespace std;
int main()
{
cout<<"Hello world!!!"<<endl;
return 0;
}

cout << 是标准输出也称为流插入
cin>> 是标准输入也称流提取

注意:使用cout标准输出(控制台)和cin标准输入(键盘)时,必须包含< iostream >头文件以及std标准命名空间

使用C++输入输出更方便,不需增加数据格式控制,比如:整形–%d,字符–%c

#include <iostream>
using namespace std;
int main()
{
int a;
double b;		
char c;
cin>>a;
cin>>b>>c;
cout<<a<<endl;
cout<<b<<" "<<c<<endl;
return 0;
}

缺省参数

缺省参数概念

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

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

缺省参数分类

  • 全缺省参数
void TestFunc(int a = 10, int b = 20, int c = 30)
{
cout<<"a = "<<a<<endl;
cout<<"b = "<<b<<endl;
cout<<"c = "<<c<<endl;
}
  • 半缺省参数(部分缺省)
void TestFunc(int a, int b = 10, int c = 20)
{
cout<<"a = "<<a<<endl;
cout<<"b = "<<b<<endl;
cout<<"c = "<<c<<endl;
}

注意

  1. 半缺省参数必须从右往左依次来给出,不能间隔着给
  2. 缺省参数不能在函数声明和定义中同时出现
//a.h
void TestFunc(int a = 10);
// a.c
void TestFunc(int a = 20)
{}
// 注意:如果声明与定义位置同时出现,恰巧两个位置提供的值不同,那编译器就无法确定到底该用那个缺省值。
  1. 缺省值必须是常量或者全局变量
  2. C语言不支持(编译器不支持)

函数重载

函数重载概念

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

int Add(int left, int right)
{
return left+right;
}
double Add(double left, double right)
{
return left+right;
}
long Add(long left, long right)
{
return left+right;
}
int main()
{
Add(10, 20);
Add(10.0, 20.0);
Add(10L, 20L);
return 0;
}

下面两个函数属于函数重载吗?

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

答案:不属于
函数重载与返回参数类型无关
只与参数个数,类型,顺序有关

名字修饰

为什么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++是通过函数修饰规则来区分,只要参数不同,修饰出来的名字就不一样,就支持了重载

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

extern “C”

⭐在一些情况下,比如我用C++写的程序,需要调一个数据结构栈,但是这个栈是用C语言实现的,那么我们怎么办呢?

1、我们创建一个工程,创建C的静态库(这里我用VS2019举例)
在这里插入图片描述在这里插入图片描述

静态库不用写主函数,编译生成的是一个.lib文件
2、在这个静态库,实现一下Stack.h和Stack.c
在这里插入图片描述3、然后我们再创建一个正常的C++工程
这个工程就是我们写的程序,需要调C的栈的静态库

4、我们C++程序要用C实现的DS栈的静态库

  • 包含这个栈的头文件Stack.h
  • 在工程属性中配置静态库的目录和添加静态库

在这里插入图片描述在这里插入图片描述在这里插入图片描述

此时编译链接会报链接错误!
为什么?
解答:

我们现在是C++程序调用C的静态库,包的C的头文件,头文件只有函数的声明,链接时,要用函数名去找函数定义的地址,但是通过前面所学的函数重载我们知道,C++的函数名修饰规则和C语言不同,所以链接时,找不到函数定义的地址。

怎么解决:
这时,我们主角就要登场了
在这里插入图片描述
我们用extern "C"
就是告诉编译器,{}里面的函数是C编译器编译的,链接的时候,也用C的函数名规则去找函数定义的地址,这样就可以链接到了。

⭐相反,如果是C实现的程序去调C++的静态库该怎么办呢?
我们的目的就是让他们链接的时候,用同样的函数名修饰规则
如果我们在C++的静态库的头文件使用extern “C” 如图
在这里插入图片描述C程序要包C++静态库的头文件
这里就有问题了
C不认识extern "C"
怎么办?
我们需要使用一下条件编译
_cplusplus只在C++中被定义所以这里条件编译后,在C++的静态库中extern "C"会被展开,告诉编译器{}里面用C的函数名修饰规则去处理。
而在C程序中这段头文件中的函数声明没有展开extern “C”
这样一来就解决了
在这里插入图片描述

引用

引用概念

引用不是新定义一个变量,而是给已存在变量取了一个别名,编译器不会为引用变量开辟内存空间,它和它引用的变量共用同一块内存空间。
比如你有一个大名,你也有一个小名,同学们还给你起了个外号,叫哪个名字都是你。

类型& 引用变量名(对象名) = 引用实体;
void Test()
{
int a = 10;
int& ra = a;//  定义引用类型
printf("%p\n", &a);
printf("%p\n", &ra);
}

我们打印出来地址是一样的,说明它们共用一块空间
注意:引用类型必须和引用实体是同种类型的

引用特性

  1. 引用在定义时必须初始化
  2. 一个变量可以有多个引用
  3. 引用一旦引用一个实体,再不能引用其他实体
void Test()
{
int a = 10;
// int& ra; // 该条语句编译时会出错 引用在定义时必须初始化
int& ra = a;
int& rra = a;//一个变量可以有多个引用
printf("%p %p %p\n", &a, &ra, &rra);//地址相同
int& ra=b;//错误   引用一旦引用一个实体,再不能引用其他实体
int d=30;
rra=d;//这里是把d赋值给b,此时a,ra,rra指向内容都变成30了
}

常引用

void TestConstRef()
{
const int a = 10;
//int& ra = 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;
}
const int a=10;
int& b=a;//权限放大 不可以

const int a=10;
const int&b=a;//权限不变 可以

int a=10;
const int&b=a;//权限缩小 可以

double a=3.14;
int b=a;//类型转换,产生临时变量
const int&c=a; //引用的是临时变量,临时变量具有常性,所以要加const

使用场景

1、做参数

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

2、 做返回值

int& Count()
{
static int n = 0//因为是static的所以出了作用域依然存在
n++;
// ...
return n;
}

首先注意一点:如果函数返回时,出了函数作用域,如果返回对象还未还给系统,则可以使用引用返回,如果已经还给系统了,则必须使用传值返回。

我们来看一段代码,看看此代码有什么问题,结果是多少?为什么?

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

输出结果是:7
解答:在这里插入图片描述当前代码问题:
1、存在非法访问,因为Add(1,2)的返回值是C的引用,但是出了Add函数作用域,函数栈帧就会销毁,此时C这块地方已经不属于自己了,可以被其他人覆盖了,此时我们访问C的位置就是非法访问了。
2、如果Add函数栈帧销毁,会清理空间的话,那我们取C位置的东西拿到的是随机值,ret就是随机值,这取决于编译器的实现

这里为什么是7不是3,就很简单了,之前C位置是3,但是后来又Add(3,4),此时,C被7覆盖了,那我们ret是C的引用,当然取到的是7喽。

传值、传引用效率比较

首先,传值值返回

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

传引用引用返回则没有拷贝这回事,这样效率会提高很多
总结一下:

引用的作用主要体现在传参和传返回值,减少拷贝提高效率

引用和指针的区别

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

int main()
{
int a = 10;
int& ra = a;
cout<<"&a = "<<&a<<endl;
cout<<"&ra = "<<&ra<<endl;
return 0;
}

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

int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
}

看一下汇编:
在这里插入图片描述汇编底层实现上是一样的。但是理解的时候要以语法层理解

引用和指针的不同点:

  1. 引用必须在定义的时候初始化,而指针最好初始化,只不过不初始化不会报错。
  2. 引用在语法上是一个变量的别名,没有开空间,而指针是存储一个变量的地址,要开空间。
  3. 引用在初始化时引用一个实体后就不能再引用其他实体,而指针可以在任何时候指向任何一个同类型实体。
  4. 没有NULL引用,但有NULL指针。
  5. 在sizeof中含义不同,引用的结果为引用类型的大小,但指针始终是地址空间所占字节数(32位是4字节64位是8字节)。
  6. 引用进行++或者–是引用实体的++或–而指针的++或–则是指针向后先前偏移一个类型大小。
  7. 有多级指针,但没有多级引用。
  8. 访问实体方式不同,指针需要解引用,而引用编译器会自己处理。
  9. 引用比指针使用起来更安全。指针使用较为复杂也更容易出错,使用指针需要考虑空指针和野指针等问题,指针太灵活,所以相对而言没有引用安全。
  10. 10.引用表面好像是传值,本质也是传地址,只是这个工作由编译器完成。指针是间接操作对象,程序中使用指针可读性不好,而引用是对象的别名,对引用对象的操作就是对目标变量的操作。

内联函数

概念:

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

正常情况下,汇编下看函数调用要执行call命令

在这里插入图片描述如果在上述函数前增加inline关键字将其改成内联函数,在编译期间编译器会用函数体替换函数的调用。

  1. 在release模式下,查看编译器生成的汇编代码中是否存在call Add
    但是release调试看不到,优化太多
  2. 在debug模式下,需要对编译器进行设置,否则不会展开(因为debug模式下,编译器默认不会对代码进行优化
    在这里插入图片描述在这里插入图片描述
    我们看到现在就没有call命令了。

我们来说说为什么会存在内联函数
:调用函数需要建立栈帧,栈帧中要保存一些寄存器,结束后又要恢复,这些如果函数调用很多次,是有时间和空间上的消耗的,特别是短小的函数,函数创建和销毁栈帧所花费的时间比你这个函数的小算法还多,频繁的调用函数效率很垃圾,那咋办?
首先我们想到了宏,但是宏使用起来容易出错,所以有了内联函数!

内联函数的特性

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

宏的优缺点?

优点:

  1. 增强代码复用性
  2. 使用带参的宏定义完成函数的调用功能,避免压栈出栈的开销,提高性能
  3. 还可以完成编译器无法实现的功能,比如##连接符

缺点:

  1. 不方便调试(因为在预编译阶段就进行了替换)
  2. 没有类型检查,不够安全
  3. 如果带有()会有边缘效应运算符优先级问题,易出错
  4. 因为是直接的文本替换,有时候会使代码可读性差,可维护性差,容易误用
  5. 因为是直接嵌入到代码中,如果宏较长,多次插入到代码会导致代码很冗余

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

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

auto关键字(C++11)

auto简介

在C语言中我们使用的auto的意思是:使用auto修饰的变量,是具有自动存储器的局部变量。
但是没啥用,因为我们平时不会用到,相当于脱裤子放屁。

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

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

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

auto的使用细则

  1. auto与指针和引用结合起来使用

用auto声明指针类型时,用auto和auto*没有任何区别,但用auto声明引用类型时则必须加&

int main()
{
int x = 10;
auto a = &x;
auto* b = &x;
auto& c = x;
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
return 0;
}
  1. 在同一行定义多个变量

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

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

auto不能推导的场景

  1. auto不能作为函数的参数
// 此处代码编译失败,auto不能作为形参类型,因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}
  1. auto不能直接用来声明数组
void TestAuto()
{
int a[] = {1,2,3};
auto b[] = {456};
}
  1. 为了避免与C++98中的auto发生混淆,C++11只保留了auto作为类型指示符的用法
  2. auto在实际中最常见的优势用法就是跟C++11提供的新式for循环,还有lambda表达式等进行配合使用。

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

范围for的语法

在C++98中如果要遍历一个数组,可以按照以下方式进行:

void TestFor()
{
	int array[] = { 1, 2, 3, 4, 5 };
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
	{
		array[i] *= 2;
	}
	for (int* p = array; p < array + sizeof(array) / sizeof(array[0]); ++p)
	{
		cout << *p << endl;
	}
}

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

使用如下:

void TestFor()
{
	int array[] = { 1, 2, 3, 4, 5 };
	for (auto& e : array)
	{
		e ++;    //因为你想影响数组里的元素,就应该用引用
	}
	for (auto e : array)
	{
		cout << e << " ";
	}
}

语法含义:
自动依次取array数组里的每一个元素赋值给e,然后自动判断结束。

范围for的使用条件

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

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

下面代码就存在问题,因为我们之前学过,数组传参之后会降维,而array必须是数组

void TestFor(int array[])
{
for(auto& e : array)
cout<< e <<endl;
}
  1. 迭代的对象要实现++和==的操作

指针空值nullptr(C++11)

C++98中:

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

void Test()
{
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)" << endl;
}
void f(int*)
{
	cout << "f(int*)" << endl;
}
int main()
{
	f(0);
	f(NULL);
	f((int*)NULL);
	return 0;
}

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

所以nullptr就比较严谨
注意

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

⭐感谢阅读,我们下期再见
如有错 欢迎提出一起交流

  • 7
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

周周汪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值