关键字
c++总计63关键字,c语言32关键字
asm | do | if | return | try | continue |
auto | double | inline | short | typedef | for |
bool | dynamic_cast | int | signed | typeied | public |
break | else | long | sizeof | typename | throw |
case | enum | mtable | static | union | wchar_t |
catch | explicit | namespace | static_cast | unsigned | default |
char | export | new | struct | using | friend |
class | extern | operator | switch | virtual | register |
const | false | private | template | void | true |
const_cast | float | protected | this | volatile | while |
delete | goto | reinterpret_cast |
c++第一个程序
#include<iostream>
using namespace std;
int main()
{
cout<<"hello world"<<endl;//打印出hello world
return 0;
}
此时我们和c语言做一下对比,发现多了一行using namespace std 语句,这句设计右命名空间,而cou类似于c语言的printf而endl类似于\n,
命名空间
在C/C++中,变量、函数和后面要学到的类都是大量存在的,这些变量、函数和类的名称将都存在于全局作用域中,可能会导致很多突。使用命名空间的目的是对标识符的名称进行本地化,以避免命名冲突或名字污染,namespace关键字的出现就是针对这种问题的。
命名空间的定义
定义命名空间,需要用到namespace关键字,后面跟的命名空间的名字,然后接一对{}即可,{}中即为命名空间的成员
命名空间的使用:
命名空间名称加左右限定符
#include<iostream>
using namespace std;
namespace s
{
int a = 10;
int add(int x, int y)
{
return x + y;
}
}
int main()
{
int ret = s::add(1, 2);
int z = s::a;
cout << ret << endl;
cout << z << endl;
return 0;
}
- 命名空间的嵌套
#include<iostream>
using namespace std;
namespace s
{
int a = 10;
int add(int x, int y)
{
return x + y;
}
namespace d
{
int sub(int x, int y)
{
return x - y;
}
}
}
int main()
{
int ret = s::d::sub(1,3);
cout << ret << endl;
return 0;
}
- 命名空间的合并
同一个工程中允许存在多个相同命名空间,编译器最后会合并在同一个命名空间中。在同一个命名空间中,禁止出现多次定义定义同一个变量
#include<iostream>
using namespace std;
namespace s
{
int a = 10;
int add(int x, int y)
{
return x + y;
}
namespace d
{
int sub(int x, int y)
{
return x - y;
}
}
}
namespace s
{
int b = 20;
}
int main()
{
cout<<s::b<<endl;
return 0;
}
命名空间的使用
命名空间的使用有三种方法:
- 命名空间名称+作用域限定符
int main()
{
cout<<s::a<<endl;
return 0;
}
- 使用using将命名空间成员引入
有点使用灵活,经常使用
using s::a;
int main()
{
cout<<a<<endl;
return 0;
}
- 使用using namespace 命名空间名称引入
这种方法变向直接把N在全局域中展开
using namespace s;
int main()
{
cout<<s::a<<endl;
return 0;
}
c++的输入与输出
- 使用cout标准输出(控制台)和cin标准输入(键盘)时,必须包含头文件以及std标准命名空间
- 使用c++输入输出更方便,不需要增加数据格式控制
缺省参数
缺省参数概念
缺省参数是声明或定义函数时为函数的参数指定一个默认值,在调用函数时,如果没有指定实参则采用默认值,否则使用实参
void a(int a = 10)
{
cout << a << endl;
}
int main()
{
a();
a(11);
return 0;
}
缺省参数分类
- 全缺省参数
void test1(int a=10,int b=20,int c=30)
{
cout<<a<<endl;
cout<<a<<endl;
cout<<a<<endl;
}
- 半缺省参数
规定半缺省参数必须从右到左依次来给,不能间隔着给;
void test2(int a,int b=20,int c=30)
{
cout<<a<<endl;
cout<<b<<endl;
cout<<c<<endl;
}
- 缺省参数不能再函数声明和定义中同时出现,理由编译器无法确定改用哪个缺省值
函数重载
函数重载概念
函数重载:是函数的一种特殊情况,C++允许在同一作用域中声明几个功能类似的同名函数,这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同,常用来处理实现功能类似数据类型不同的问题,返回值相不相同无所谓,相同的类型的顺序无论怎么替换都不符合函数重载
void add(int x,int y)
{
cout<<x+y<<endl;
}
void add(double x,double y)
{
cout<<x+y<<endl;
}
void add(double x,int y)
{
cout<<"调用double,int类型的函数"<<endl;
}
void add(int x,double y)
{
cout << "调用int,double类型的函数" << endl;
}
名字修饰
现在有一个问题为啥c语言不支持函数重载,而c++支持函数重载
在C/C++中,一个程序要运行起来,需要经历以下几个阶段:预处理、编译、汇编、链接。
此时我们引入函数名修饰规则(每个编译器都有自己的规则)
此时我们讲解的是Linux下的函数修饰规则
- 采用c语言编译器编译后结构
#include<stdio.h>
int add(int x,int y)
{
return x+y;
}
int main()
{
add(1,2);
return 0;
}
#include<iostream>
using namespace std;
int add(int x,int y)
{
return x+y;
}
double add(double x,double y)
{
return x+y;
}
由上图可以知道g++的函数名修饰规则为成**【_Z+函数长度+函数名+类型首字母】**
extern “C”
由于c语言和c++对函数的命名规则不相同,导致c++的函数c语言无法使用
有时候在C++工程中可能需要将某些函数按照C的风格来编译,在函数前加extern “C”,意思是告诉编译器,将该函数按照C语言规则来编译。
引用
引用概念
语法:类型& 引用变量名(对象名)=引用实体(变量);
引用不是新定义一个变量,而是给已存在变量取了一个别名,编译器不会为引用变量开辟内存空间,它和它引用的变量共用同一块内存空间。
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int& ra = a;
cout << &a << endl;
cout << &ra << endl;
return 0;
}
注意:引用类型必须和引用实体是同种类型的
引用特性
- 引用在定义时必须初始化
- 一个变量可以有多个引用
- 引用一旦引用一个实体,再不能引用其他实体
常引用
一个变量如果要对一个常量取别名要加const
变量具备读写的权限,但常量只具备读的权限,不具备写的权限::
当然一个被const修饰的变量想要引用一个变量是可以的
这有点想venn图,大的可以推出小的,小的推不出大的
对于不同类型的变量可以加个const修饰
使用场景
做参数
#include<iostream>
using namespace std;
void Swap(int& x,int &y)
{
int tmp=x;
x=y;
y=tmp;
}
int main()
{
int x=1;
int y=2;
Swap(x,y);
cout<<"x="<<x<<" y="<<y<<endl;
}
做返回值
int & Count()
{
int n=0;
n++
return n;
}
int main()
{
int &ret=Count();
cout<<1<<endl;
cout<<2<<endl;
cout<<3<<endl;
cout<<ret<<endl;
return 0;
}
为什么ret的值变成随机值,请学下函数的栈帧建立与销毁
如何放ret变成随机值???
直接在Count函数里面的n加个static
传与引用作为返回值的效率比较
#include<iostream>
#include <time.h>
using namespace std;
struct A { int a[10000]; };
void TestFunc1(A a)
{
}
void TestFunc2(A& a)
{
}
void TestRefAndValue()
{
A a;
// 以值作为函数参数
size_t begin1 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc1(a);
size_t end1 = clock();
// 以引用作为函数参数
size_t begin2 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc2(a);
size_t end2 = clock();
// 分别计算两个函数运行结束后的时间
cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
int main()
{
TestRefAndValue();
return 0;
}
通过上述代码的比较,发现传值返回比传引用返回的效率更慢
为啥怎么慢呢??
在传实参或者返回变量的过程中,函数不会直接传变量本身,而是进行一份临时的拷贝,会有一定的系统开销
然而引用由于是直接使用变量本身,不需要临时拷贝,所以效率会相对与传值更高些
引用与指针的区别
- 引用在定义时必须初始化,指针没有要求
- 引用在初始化时引用一个实体后,就不能再引用其他实体,而指针可以在任何时候指向任何一个同类型实体
- 没有NULL引用,但有NULL指针
- 在sizeof中含义不同:引用结果为引用类型的大小,但指针始终是地址空间所占字节个数(32位平台下占4个字节)
- 引用自加即引用的实体增加1,指针自加即指针向后偏移一个类型的大小
- 有多级指针,但是没有多级引用
- 访问实体方式不同,指针需要显式解引用,引用编译器自己处理
- 引用比指针使用起来相对更安全
内联函数
概念
以inline修饰的函数叫做内联函数,编译时C++编译器会在调用内联函数的地方展开,没有函数压栈的开销,内联函数提升程序运行的效率。
#include<iostream>
using namespace std;
inline int add(int x,int y)
{
return x+y;
}
int main()
{
int ret=add(1,2);
cout<<ret<<endl;
return 0;
}
使用汇编语言进行查看
特性
1.1. inline是一种以空间换时间的做法,省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
2. inline对于编译器而言只是一个建议,编译器会自动优化,如果定义为inline的函数体内有循环/递归等等,编译器优化时会忽略掉内联。
3. inline不建议声明和定义分离,分离会导致链接错误。因为inline被展开,就没有函数地址了,链接就会找不到。
宏的优缺点
优点:
1.增强代码的复用性
2.提高性能
缺点:
1.不方便调试宏(因为编译阶段宏就进行了替换)
2.代码可读性差,维护性不易,
3.没有类型安全的检查
C++使用了下面两种方法方式替换宏:
1.常量定义换用const
2.函数定义换用内联函数
auto关键字
简介
在早期C/C++中auto的含义是:使用auto修饰的变量,是具有自动存储器的局部变量,但遗憾的是一直没有人去使用它.
C++11中,标准委员会赋予了auto全新的含义即:auto不再是一个存储类型指示符,而是作为一个新的类型指示符来指示编译器,auto声明的变量必须由编译器在编译时期推导而得。
用法
1.用auto声明指针类型时,用auto和auto* 没有任何区别,但auto声明引用类型时,必须加&符号
#include<iostream>
using namespace std;
int main()
{
int x=10;
auto a=x;
auto b=&x;
auto* c=&x;
auto& d=x;
}
2.同一行定义多个变量
同一行定义多个变量必须相同类型,否则报错
#include<iostream>
using namespace std;
int main()
{
auto a = 1, b = 2;
auto c = 1, d = 2.0;
return 0;
}
3.auto 无法用作函数的参数
因为在声明时,编译不知道参数是什么类型的
4.auto 无能用来声明数组
因为推导不出数组是什么类型
auto与for的使用联合
对于一个有范围的集合而言,由程序员来说明循环的范围是多余的,有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ :”分为两部分:第一部分是范围内用于迭代的变量,第二部分则表示被迭代的范围。
#include<iostream>
using namespace std;
int main()
{
int arr[] = { 2,2,3,4,5 };
for (auto e : arr)
{
cout << e << endl;
}
return 0;
}
for (auto e : arr)的意思是将数组arr中的内容依次取来赋值给变量e,这样在for循环中就可以输出e的内容也就是数组中的内容了。