0%

C++基础语法

命名空间

对标识符的名称进行本地化,以避免命名冲突或名字污染,namespace关键字的出现就是针对这种问题的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
namespacs dog//命名空间为dog
{
void print(int a)
{
printf(" %d \n", a);
}
int a;
int b;//可定义变量,也可定义函数

namespace big_dog//可以嵌套
{
void fun1(int a)
{
printf("%d\n", a);
int a;
int b;
}
}
}

namespace dog//可以分段写,最后会整合在一起
{
int c;
int d;
void fun2()
{
printf("hehe\n");
}
}

void fun3()
{
a = 10;//局部域
dog::a = 20;//命名空间域
dog::big_dog::a = 30;//命名空间域
::a = 40;//全局作用域
}

int main()
{
fun3();
return 0;
}

使用方式:

  1. 命名空间+::+成员
  2. 引入成员using + 命名空间 + ::+成员,后边使用时不用加作用域,成员暴露在全局域中,如果全局域中有同名成员,会导致命名冲突
  3. 展开命名空间 using 命名空间,命名空间所有成员暴漏在全局域中

输入输出方式

头文件 + std命名空间

输出 cout \<\< a \<\< “\\n”; 输出a\\n

输入 cin >> b; 输入b

支持连续的输入输出

字符串指针输出内容

非字符串指针输出地址

缺省参数

给参数定义一个默认值,实际使用时,如果没有传参,对应的行参使用默认值,参数传递一个用一个(必须从第一个参数开始传递,参数要连续的传递

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void fun1(int a = 1, int b = 2, int c = 3)//全缺省
{
std::cout << a << b << c << std::endl;
}
void fun2(int a, int b = 2, int c = 3)//半缺省,必须从右到左连续无间断
{
std::cout << a << b << c << std::endl;
}
void fun3(int a = 1, int b = 2, int c)//非法
void fun4(int a = 1, int b, int c = 3)//非法

//错误写法,缺省值只能出现在声明或定义的地方,不能同时出现
void fun5(int a = 1, int b = 2, int c = 3);//声明
void fun5(int a = 100, int b = 200, int c = 300)//定义
{
std::cout << a << b << c << std::endl;
}

函数重载

同一个作用域内声明几个功能类似的同名函数,这些同名函数的行参列表(参数个数或类型 或顺序)必须不同, 常用于处理实现功能类似数据类型不同的问题。

仅仅返回值不同,不能构成重载。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
int Add(int a, int b)
{
return a + b;
}

float Add(float a, float b)
{
return a + b;
}

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

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

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

void test3()
{
std::cout << Add((float)1.5, (float)1.6) << std::endl;
}

函数重载如何实现的

1
int Add(int a = 1, int b = 2)

编译器编译之后的底层函数名称:

  • VS:C编译器 :无法解析的外部符号 _Add
  • VS:C++编译器:无法解析的外部符号 ?Add\@\@YAHH\@Z
  • g++编译器:_Z3Addii
  • _Z:规定的前缀,3:函数名字的字数,Add:函数名,ii:有两个int类型参数

函数名修饰规则:

  • C编译器:函数名中不包含参数信息
  • C++编译器:函数名中包含参数信息
1
2
3
4
5
6
7
8
9
10
11
int Add(int a, int b)
//C编译器均为:_Add
//g++编译器:_Z3Addii
float Add(float a, float b)
//_Z3Addff
int Add(int a, int b, int c)
//_Z3Addiii
int Add(char a, int b)
//_Z3Addci
int Add(int a, char b)
//_Z3Addic

extern “C”

按照C语言规则编译

1
2
3
4
extern "C"{
int sub(int a, int b);
int mul(int a, int b);
}

引用

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

  • 类型 + \& + 引用名称
1
2
3
4
5
6
7
8
9
10
11
12
int a = 10;
int& ra = a;
int& ra2 = a;
const int b = 10;
const int& rb = a;
const int& r = 10;
//引用类型和引用实体必须是相同类型
double d = 2.0;
double& rd = d;
int c = d;
const int& rd2 = d;
//d隐式类型转换,生成一个临时int变量,rd2此时指向为此临时变量,而临时变量具有常性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void swap(int& ra, int& rb)
{
int tmp = ra;
ra = rb;
rb = tmp;
}

int& Add2(int& ra)//int& Add3(int a),引用做返回值,注意返回值的周期一定要大于函数生命周期
{
return ++ra;
}

void test4()
{
int a = 10;
int b = 20;
swap(a, b);
std::cout << a << b << std::endl;
int& c = Add2(a);
std::cout << a << b << std::endl;
}

底层实现:引用通过指针实现,定义一个引用类型的变量相当于定义一个指针类型的变量。

语法:引用是别名,不是指针,没有发生拷贝。

目前可以认为引用是指针的一层封装,更加简单化的指针

内联函数

1
inline int Add(int a, int b)

关键字 :“inline”

内联函数:编译器编译时,会进行函数指令展开,没有栈帧的开销,提高代码效率

替代宏函数的使用

inline只是一个建议,编译器会根据实际情况进行判断,如果代码简单,直接展开,代码复杂,不会展开

inline不支持分离定义

auto

自动类型推导,不代表具体类型,编译时根据初始化表达式自动推导

1
2
3
4
5
6
auto a = 2;
auto b = 2.0;
auto c = 'a';
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;

auto定义的变量必须初始化

auto可以定义多个变量,每一个表达式的类型要一致

auto定义指针时,加不加 * 没有区别,定义引用类型时,必须加 \&

函数参数类型不能使用auto, 定义数组不能使用auto

基于范围的for循环

范围内用于迭代的变量 : 被迭代的范围

1
2
3
int array[] = {1, 2, 3, 4, 5, 6};
for(int i - 0; i < sizeof(array) / sizeof(array[0]); i++)
for(auto e : array)

使用场景:数据范围确定

指针空值nullptr

  1. 其作为关键字,不需要包含头文件
  2. sizeof(nullptr) == sizeof ((void*) 0 )
  3. 为了提高代码健壮性,尽量使用nullptr表示指针空值
-------------本文结束感谢您的阅读-------------