目录
2.使用using namespace 命名空间名称 引入(全展开)
一.命名空间
1.命名空间作用
命名空间的目的是对标识符的名称进行本地化,以避免命名冲突或名字污染,namespace关键字的出现就是针对这种问题的。
2.命名空间定义
定义命名空间,需要使用到namespace关键字,后面跟命名空间的名字,然后接一对{}即可,{}
中即为命名空间的成员。
namespace 命名空间名字
{
....
}
#include<stdio.h>
//
namespace wws
{
//命名空间可以含变量,函数,结构体
int rand = 0;
void Add(int a, int b)
{
printf("%d", a + b);
}
struct Node
{
struct Node* p;
int val;
};
}
//命名空间可以嵌套
namespace qlsf
{
namespace wws
{
//命名空间可以含变量,函数,结构体
int rand = 0;
void Add(int a, int b)
{
printf("%d", a + b);
}
struct Node
{
struct Node* p;
int val;
};
}
}
//同一个工程中可以有同名的命名空间 编译器会合成在一起 (命名空间可以不连续)
// 例如在 .h .cpp中有重名的命名空间会合在一起
//test.h
namespace wws
{
int rand = 0;
}
//test.cpp
namespace wws
{
struct Node
{
struct Node* p;
int val;
};
}
3.命名空间的使用
1.加命名空间和作用域限定符 (指定引用)
#include<stdio.h>
//
namespace wws
{
//命名空间可以含变量,函数,结构体
int rand = 0;
void Add(int a, int b)
{
printf("%d", a + b);
}
struct Node
{
struct Node* p;
int val;
};
}
int main()
{
//加命名空间名称及作用域限定符
printf("%d", wws::rand);
}
2.使用using namespace 命名空间名称 引入(全展开)
namespace wws
{
//命名空间可以含变量,函数,结构体
int rand = 0;
void Add(int a, int b)
{
printf("%d", a + b);
}
struct Node
{
struct Node* p;
int val;
};
}
//全展开
using namespace wws;
int main()
{
printf("%d", rand);
}
3.使用using将命名空间中某个成员引入(部分展开)
namespace wws
{
//命名空间可以含变量,函数,结构体
int rand = 0;
void Add(int a, int b)
{
printf("%d", a + b);
}
struct Node
{
struct Node* p;
int val;
};
}
//部分展开
using wws::rand;
int main()
{
printf("%d", rand);
}
二.C++输出,输入
使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时,必须包含< iostream >头文件
以及按命名空间使用方法使用std。
三.缺省函数
1.缺省参数的定义
缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时,如果没有给函数参数传值,就使用缺省值。
注意:缺省值必须是常量或者全局变量(防止改变)
案例
2.全缺省和半缺省
全缺省(每一个参数都指定一个缺省值)
半缺省 函数参数一定要从右往左缺省
举个反例
void Funt2(int a=10,int b)
{
......
}int main()
{
Funt2(1);
}像这样从左往右缺省,只传一个值时,b就无法得到值
即使传2个值同样编译也是通不过去的
缺省参数只能从右往左缺省参数,不能跳跃传参,指定传参。
3.缺省参数的说明和定义
缺省参数不能在函数声明和定义中同时出现
如果同时出现,会报错
但缺省参数在声明给,定义不给编译也是可以通过的(尽量不要同时出现)
四.函数重载
1.函数重载定义
C++允许在同一作用域中声明几个功能类似的同名函数,这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同,常用来处理实现功能类似数据类型不同的问题。
#include<iostream>
using namespace std;
namespace wws
{
void funt(int a, int b)
{
cout << a << b << endl;
}
//参数个数不同
void funt(int a, int b,int c)
{
cout << a << b <<c<< endl;
}
//参数类型不同
void funt(int a, double b)
{
cout << a << b << endl;
}
//参数顺序不同
void funt(double a, int b)
{
cout << a << b << endl;
}
}
using namespace wws;
int main()
{
funt(1, 2);
funt(1, 2, 3);
funt(1, 2.3);
funt(2.3, 1);
}
注意:
1.函数重载必须是在同一个作用域中才存在。分别在两个作用域的同名函数即使同时展开,也是不能称作函数重载。(如果同名函数的参数部分还完全相同的话就会发生调用不明确)
2.但如果两个函数函数名和参数是一样的,返回值不同是不构成重载的,因为调用时编译器没办法区分。
3.两个函数函数名一样,参数都是同一个变量,但有一个被const修饰,也构成函数重载。
如果两个作用域的同名函数的参数部分不完全相同,同时展开编译时也是可以找到对应的函数的
2.为什么C语言不支持函数重构
简单来说,C语言是根据函数名称来找函数的,而C++是根据修饰后的函数名称。(参数 个数,类型,顺序不同 函数名称变化不同)
五.引用
1.引用概念
引用不是新定义一个变量,而是给已存在变量取了一个别名,编译器不会为引用变量开辟内存空
间,它和它引用的变量共用同一块内存空间。
实例
2.引用的的特点
1.引用可以嵌套(就像一个人可以有多个别名)
2.引用在定义时必须初始化
3.引用不能像指针一样 改变指向的变量(初始化完后就不能改变)
4.因为编译器不会为引用变量开辟内存空间,对引用变量用 sizeof() 计算的变量的大小
5.对数组引用要知道它的数组的大小
6.对变量引用时权限不能变大(只能进行缩小 或者 平移)
7.类型转换(duoble b=3.14; int i=b)/ 表达式运算(int a=x+y) 过程中会产生临时变量,对临时变量进行引用会发生权限的放大(临时变量是常量不能改变)
8.语法层面上引用变量是不开空间,指针变量开空间。但底层上引用也是通过指针的方式实现的(也开辟空间)
9.引用没有空引用,但不是绝对的(int& r = *ptr;仍可以编译通过)
3.引用的实践
引用可以一定程度上代替指针的作用
六.内联函数
1.内联函数定义
以inline修饰的函数叫做内联函数,编译时C++编译器会在调用内联函数的地方展开,没有函数调
用建立栈帧的开销,内联函数提升程序运行的效率。
#include<iostream>
using namespace std;
inline int Add(int a, int b)//内敛函数
{
return a + b;
}
int main()
{
int ret = 0;
ret = Add(1, 2);//此时不会通过函数名来找下一步指令,而是直接把Add函数直接展开
return 0;
}
2.内敛函数的特性
1.nline只是建议编译器把内敛函数展开,具体是否展开要看编译器是怎么实现的,一般把不
是递归、且频繁调用的函数采用inline修饰。
2. inline是一种以空间换时间的做法,如果编译器将函数当成内联函数处理,在编译阶段,会用函数体替换函数调用,缺陷:可能会使目标文件变大,优势:少了调用开销,提高程序运行效率。
3. inline不建议声明和定义分离,分离会导致链接错误。因为inline被展开,就没有函数地址
了,链接就会找不到。
//Test.h
#pragma once
inline int Add(int a, int b);
//Test.cpp
#include"Test.h"
inline int Add(int a, int b)
{
return a + b;
}
//main.cpp
#include<iostream>
using namespace std;
#include"Test.h"
int main()
{
int ret = 0;
ret = Add(1, 2);
return 0;
}
//Test.h
#pragma once
inline int Add(int a, int b)
{
return a + b;
}
//main.cpp
#include<iostream>
using namespace std;
#include"Test.h"
int main()
{
int ret = 0;
ret = Add(1, 2);
return 0;
}
建议直接在.h声明+定义
3.class类中的内敛函数
在类的声明内部声明和定义的函数叫做内联成员函数,如下面例子,函数funt1是普通的成员函数,函数funt2是隐式的内联函数,函数funt3是显式的内联函数。
//.h
class A
{
public:
void funt1();//普通成员函数 声明与定义分离(在不同文件)
void funt2()//隐式内敛成员函数 声明和定义不分离(都在类内部)
{
cout << "隐式内敛";
}
inline void funt3();//显式内敛成员函数 声明与定义分离(声明在类内,定义在类外。在同一个文件)
private:
};
inline void A::funt3()
{
cout << "显式内敛";
}
int main()
{
return 0;
}
//.cpp
#include"Test.h"
void A::funt1()
{
cout << "普通成员函数";
}
七.auto关键字
1.auto作用
可以当作任何变量的单位
2.auto使用细则
1.auto定义变量时要初始化
2.auto可以接收任何类型,auto*必须是指针类型。
3.auto不能在同一行定义多个不同类型的变量
4.auto不能当函数参数(函数要确定参数的大小)
5.auto不能声明数组
3.typedef重命名
typedef也可以实现auto类似的功能,但是并不方便,况且更容易出错。
八.基于范围的for循环
我们可以通过这种方法来便捷的遍历数组。
自动取数组中的值来赋给i,自动++,直到结束。
注意:for(auto i : a) a必须是数组名 i为数组下标 不能是指针变量(想从第二个开始遍历,a+1是不行的)
同样下面的代码也是不行的
void funt(int a[])
{
for (auto i : a)
{
cout << i << ' ';
}
}
typedef char* pstring;
int main()
{
int a[6] = {1,2,3,4,5,6};
funt(a);
return 0;
}
因为数组不支持传参,传过去的只是数组首元素地址。
如果想改变数组中的元素,可以采用引用的方式
九.指针空值nullptr
NULL实际是一个宏,在传统的C头文件(stddef.h)中是这样定义的
#define NULL 0
可以看到,NULL可能被定义为字面常量0,或者被定义为无类型指针(void*)的常量。
因此会产生这样的代码
我们funt(NULL)是想打印出int*,但还是调用到了funt(int).
为了解决这个问题我们可以使用nullptr,它等价于(int*)NULL.
为了提高代码的健壮性,在后续表示指针空值时建议最好使用nullptr