C++基础篇
- 什么是C++
- 命名空间
- 命名空间的三种使用方式
- C++的输入和输出
- 缺省参数
- 缺省参数分类
- 函数重载
- 引用
- 引用的使用场景
- 常引用
- 指针和引用的区别
- auto关键字
- auto使用细则
- auto不能推导的场景
- 基于范围的for循环
- 范围for的使用条件
- 指针空值nullptr
什么是C++
1982年,Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念,发明了一种新的程序语言。为了表示该语言与C语言的渊源关系,将其命名为C++。因此,C++是基于C语言产生的,它既可以进行C语言的过程化程序设计,又可以进行以抽象数据类型为特点的基于对象的程序设计,还可以进行面向对象的程序设计。
现在C++比较主流的两个版本还是C++98和C++11。
C++98:C++标准的第一个版本,绝大多数编译器都支持,以模板方式重写C++标准库,引入了STL(标准模板库)
C++11:增加了许多特性,使得C++更像一种新语言。比如:正则表达式、基于范围的for循环,auto关键字、新容器、列表初始化、标准线程库等。
命名空间
使用命名空间的目的是对标识符的名称进行本地化,避免命名冲突或命名污染。
#include <stdio.h>
#include <stdlib.h>
int rand = 0;
int main()
{
printf("%d\n", rand);
return 0;
}
C语言没有办法解决上述类似的命名冲突问题,所以C++提出了namespace
来解决。
命名空间中可以定义变量/函数/类型,可以嵌套。同一个工程中是允许存在多个相同名称的命名空间的,这些命名空间中的内容最后会合并到一起。
定义一个命名空间就定义一个新的作用域,命名空间中的所有内容都局限于该命名空间。
int a = 0;
namespace zs
{
int a = 1;
}
/*
* 命名空间展开
* 先到全局域中去找,如果没有还会在展开的zs域中去找
*/
using namespace zs;
int main()
{
int a = 2;
printf("%d\n", a);// 2
printf("%d\n", ::a);// 0
printf("%d\n", zs::a);// 1
return 0;
}
所以,std
作为C++标准库的命名空间,很多时候C++程序中的using namespace std
将标准库中的东西都暴露出来,在实际开发中并不是好的做法。那如何合理使用std命名空间呢?
可以通过指定命名空间 + 展开常用的库对象/类型等方式来解决。
命名空间的三种使用方式
- 加命名空间名称及作用域限定符
- 使用
using
将命名空间中某个成员引入 - 使用
using namespace 命名空间名称
引入
C++的输入和输出
- 使用
cout
标准输出对象和cin
标准输入对象时,必须包含<iostream>
头文件,并按命名空间使用方法使用std
。 <<
是流插入运算符,>>
是流提取运算符。- 使用C++输入输出可以自动识别变量类型。
#include <iostream>
using namespace std;
int main()
{
int i = 0;
float f = 0;
char c = 0;
cin >> i >> f >> c;
cout << i << ' ' << f << ' ' << c << endl;
return 0;
}
缺省参数
缺省参数是指在声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时,如果没有指定实参,则采用形参的缺省值,否则使用指定的实参。
缺省参数分类
- 全缺省参数
void Cout(int a = 1, int b = 2, int c = 3)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl << endl;
}
int main()
{
Cout();
Cout(10); // 从左往右传值
Cout(10, 20);
Cout(10, 20, 30);
return 0;
}
- 半缺省参数
// 从右往左连续缺省,不能间隔
void Cout(int a, int b = 2, int c = 3)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl << endl;
}
int main()
{
Cout(10);
Cout(10, 20);
Cout(10, 20, 30);
return 0;
}
缺省参数不能在函数声明和定义中同时出现。声明和定义都有的时候声明中给缺省参数。
缺省值必须是常量或者全局变量。
函数重载
函数重载是函数的一种特殊情况。C++允许在同一作用域中声明几个功能类似的同名函数。这些同名函数的形参列表(参数个数\类型\类型顺序)不同,借此常用来处理功能类似而数据类型不同的问题。
void CppSwap(int* a, int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
void CppSwap(float* a, float* b)
{
float tmp = *a;
*a = *b;
*b = tmp;
}
int main()
{
int i1 = 1;
int i2 = 2;
float f1 = 1.1f;
float f2 = 2.2f;
CppSwap(&i1, &i2);
CppSwap(&f1, &f2);
cout << "i1 = " << i1 << endl;
cout << "i2 = " << i2 << endl;
cout << "f1 = " << f1 << endl;
cout << "f2 = " << f2 << endl;
return 0;
}
但是C语言并不支持函数重载,如果C语言想要实现上面的交换就需要定义不同的函数来完成了。
void CSwapi(int* a, int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
void CSwapf(float* a, float* b)
{
float tmp = *a;
*a = *b;
*b = tmp;
}
int main()
{
int i1 = 1;
int i2 = 2;
float f1 = 1.1f;
float f2 = 2.2f;
CSwapi(&i1, &i2);
CSwapf(&f1, &f2);
printf(" i1 = %d\n i2 = %d\n", i1, i2);
printf(" f1 = %.1f\n f2 = %.1f\n", f1, f2);
return 0;
}
这里就可以初步认识到函数重载的意义:让用的地方很方便,就像用同一个函数一样。
那为什么C++支持函数重载,而C语言不支持呢?C++又是如何支持函数重载的呢?
这里通过程序编译链接的过程来进行解释。
有3个文件:func.h
,func.c
,test.c
,编译链接过程如下:
但是,如果是用gcc编译,会报错:
用g++编译,能够正常输出:
通过查看汇编下的代码可以发现,两个func
函数的命名并不相同:<_Z4funcid>
和<_Z4funcdi>
【_Z+函数长度+函数名+类型首字母】,对应的函数地址自然不相同。
但是C语言对于函数的命名规则是直接使用函数名,这就导致如果两个函数重名,C语言编译器就无法区分。
所以,就可以知道C++通过函数名修饰规则来进行同名函数的区分来达到重载,C语言因为不能对同名函数进行区分也就不能支持函数重载了。
引用
引用就是给已经存在的变量取一个别名。编译器不会为引用变量开辟内存空间,而是和被引用的变量共用一块内存空间。
引用变量的定义形式:类型& 引用变量名(对象名) = 引用实体
注意:引用类型必须和引用实体是同种类型的
引用特性:
- 引用在定义时必须初始化
- 一个变量可以有多个引用
- 引用一旦引用了一个实体,在不能引用其它实体
引用的使用场景
- 引用做参数
void Swap(int& a, int& b)
{
int tmp = a;
a = b;
b = tmp;
}
int main()
{
int a = 1;
int b = 2;
Swap(a, b);
cout << "a = " << a << endl;
cout << "b = " << b << endl;
return 0;
}
引用可以用作输出型参数。例如交换两个变量的值,可以避开使用指针来完成。
引用还可以对大对象进行传参,提高效率。
2. 引用做返回值
使用引用做返回值,必须确保出了函数作用域,返回对象仍不会被销毁。否则只能选择传值返回。
int& RetRef()
{
//int count = 0;// 只能传值返回
static int count = 0;// 可以传引用返回
++count;
//...
return count;
}
引用返回的语法含义就是返回 返回对象 的别名。所以如果用普通变量接收,得到的是引用变量中存储的值;如果用引用变量接收,得到的就是这个引用变量。
同时,引用返回也可以减少拷贝,提高效率。
常引用
const int i = 1;
int& ii = i;// error
由const int
到int
权限被放大了,会报错。所以只能选择权限平移const int& ii = i;
。
int i = 1;
const int& ii = i;
由int
到const int
权限被缩小了,这样是可以的。这时i
有读和写的权限,而ii
只有读的权限了。
const int& i = 10;
常量10
只具有读的属性,所以需要用const
修饰。
int i = 1;
double& rd = i;//error
const double& rd = i;//correct
引用类型和引用实体必须是同种类型的,否则会报错。但是经过const
修饰后,又不再报错了,这时为什么呢?
变量i
在给到rd
之前,是会在中间发生隐式类型转换的。将int
类型的值转换成double
类型的值,给到临时变量tmp
,而rd
实际上只是临时变量tmp
的引用变量。
所以有时候在使用函数调用的时候,如果使用引用传参,并且函数内如果不改变引用参数,那么就建议尽量用const
引用传参。
void func(const int& n)
{
//...
}
int main()
{
int a = 10;
const int b = 20;
func(a);//权限缩小
func(b);
func(30);
return 0;
}
指针和引用的区别
在语法概念上,引用就是一个别名,没有独立空间,和其引用实体共用同一块空间。
但在底层实现上,引用是按照指针的方式来实现的,是开辟了空间的。
引用和指针的汇编代码对比:
引用和指针的不同点:
- 概念上引用是一个变量的别名;指针是一个变量的地址。
- 引用在定义时必须初始化;指针没有要求
- 引用在引用一个实体后,就不能再引用其它实体了;指针可以更改指向。
- 没有NULL引用;但有NULL指针。
- sizeof的含义不同:引用结果是引用类型的大小;指针始终是 4 or 8 byte。
- 引用自加是引用的实体+1;指针自加是指针向后偏移一个类型的大小。
- 有多级指针;但没有多级引用。
- 指针访问实体需要显式解引用;引用编译器自己处理。
- 指针更强大,也更危险,更复杂;引用相对局限一些,但更安全,更简单
auto关键字
在编程时,常常需要把表达式的值赋值给变量,这就要求在声明变量的时候清楚地知道表达式的类型。然而有时候要做到这点并非那么容易,因此C++11就给auto
赋予了新的含义。
C++11中,标准委员会赋予了auto
全新的含义:作为一个新的类型指示符来指示编译器(为了避免与C++98中的auto发生混淆,C++11只保留了auto作为类型指示符的用法)。auto声明的变量必须由编译器在编译时期推导而得,因此使用auto
定义变量时必须对其进行初始化。
所以auto
并非是一种“类型”的声明,而是一个类型声明的“占位符”,编译器在编译期间会将auto
替换为变量实际的类型。
auto使用细则
- 用
auto
声明指针类型时,使用auto
和auto*
没有任何区别;但用auto
声明引用类型时则必须加&
。 - 当在同一行声明多个变量时,这些变量必须是相同的类型,否则编译器会报错。因为编译器实际只会对第一个类型进行推导,然后用推导出来的类型定义其它的变量。
auto a = 1, b = 2;
auto c = 3, d = 4.4; // error
auto不能推导的场景
- auto不能用于函数的参数中
//编译器无法对a的类型进行推导
void TestAuto(auto a)
{}
- auto不能直接用于声明数组
int a[] = {1, 2, 3};
auto b[] = {4, 5, 6}; // error
基于范围的for循环
对于一个有范围的集合,由程序员来说明其范围是多余的,有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。
for循环后的括号由冒号:
分为两部分:第一部分是范围内用于迭代的变量,第二部分则表示被迭代的范围。
范围for的使用条件
for循环迭代的范围必须是确定的。
对于数组而言,就是数组中第一个元素到最后一个元素的范围;对于类而言,应该提供begin和end的方法,begin和end就是for循环迭代的范围。
指针空值nullptr
在良好的C/C++变成习惯中,声明一个变量时最好给该变量一个合适的初始值,否则可能会出现不可预料的错误。比如未初始化的指针。
而这里要说的是,用于初始化指针的NULL
实际是一个宏。在传统的C头文件中,可以看到如下的定义:
可以看到,NULL
在C++环境中可能被定义为字面常量0
,这就可能就会导致一些程序上的错误和麻烦。
void func(int)
{
cout << "int" << endl;
}
void func(int*)
{
cout << "int*" << endl;
}
int main()
{
func(0);
func(NULL);
func((int*)NULL);
return 0;
}
上面程序本意是想通过func(NULL)
调用func(int*)
函数,但是由于NULL
被定义为了0
,就与预想的执行结果相悖了。
所以如果想按照指针的方式来使用,必须对其进行强转(int*)0
。
但是为了更好地解决上面的问题,C++11引入了nullptr
作为关键字,表示指针空值,而且在C++11中,sizeof(nullptr)
与sizeof((void*)0)
所占的字节数相同。