一些简单的c++入门知识

1 命名空间
在C/C++中，变量、函数和类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。即命名空间可以限定标识符名称的作用域,有时如果标识符名称相同,但只要合理利用namespace就可以限定该变量或函数或类名的作用域,这样就不会引起冲突,从而增加了函数的安全性。
所以一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。
1 命名空间的定义

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

命名空间的使用分为三种,如下
1 加命名空间名称及作用域限定符

int main() {
    
    
	printf("%d\n", N::a);      
	return 0; 
}

2 使用using引入命名空间成员

using N::b;
int main() {
    
    
	printf("%d\n", N::a); 
	printf("%d\n", b);
	return 0; 
}

3 使用using namespace将命名空间名称引入

//注意:该方式一般不推荐使用,它将命名空间中的成员名全局化,类似于全局变量
//这在一定程度上违背了命名空间设计的初衷
//这里为了方便我用了using namespace
using namespace N;
int main() {
    
    
	printf("%d\n", a); 
	printf("%d\n", b);
	return 0; 
}

2 c++的输入&输出
cout标准输出,cin标准输入
使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含< iostream >头文件以及std标准命名空间。(早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此推荐使用 +std的方式。)
输出

using namespace N;
using namespace std;
int main() {
    
    
	cout << "hello world" << endl;   //输出hello world,并且换行,endl即为换行
	cout << a;               //输出变量a
	//以下注释掉的两行为不使用using namespace的输出
	//std::cout << "hello world" << std::endl;   
	//std::cout << a;               
	return 0; 
}

输入(从键盘)

using namespace std;
int main() {
    
    
	int c;
	char d;
	cin >> c;   //从键盘输入整形c
	cin >> d;   //从键盘输入字符型d
	cin >> c >> d;  //依次从键盘输入c,d
	return 0; 
}

通过以上两例子可以看出,它比c中的输入输出使用更加方便(输入输出时不用加数据格式控制%d,%c等等),功能更加强大(可以连续输出输入);
3 缺省参数
概念:缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。

namespace N {
    
    
	int a = 10;    
	int b = 20; 
	//半缺省参数   
	int Add(int left, int right=10) {
    
     
		return left + right; 
	}
	
	//下列注释掉的三行,编译不会通过
	//因为缺省参数规定:半缺省参数必须从右往左依次来给出，不能间隔着给 
	//int add(int left = 10, int right) {
    
    
	//	return left + right;
	//}
	
	//全缺省参数
	int Sub(int left=10, int right=10) {
    
    
		return left - right; 
	}
}
int main() {
    
    
	Add(10);     //left通过传参赋值为10,right参数缺省使用定义中的默认值10
	Add(10, 20);   //left赋为10,right赋为20,即若调用时参数没有缺省,
	               //优先使用调用时的参数
	Sub();        //全部缺省,全部使用默认值
	return 0; 
}

缺省参数使用注意:

半缺省参数必须从右往左依次来给出，不能间隔着给
缺省参数不能在函数声明和定义中同时出现
缺省值必须是常量或者全局变量
C语言不支持（编译器不支持）
4 函数重载
概念:是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数或类型或顺序)必须不同，常用来处理实现功能类似数据类型不同的问题

//例如如下四个函数虽然函数名相同,但是却是不同的函数
int Add(int left, int right) {
    
        
return left+right; 
}
//类型不同
double Add(double left, double right) {
    
       
return left+right; 
}
//个数不同
int Add(int left, int middle,int right) {
    
        
return left+middle+right; 
}
//顺序不同
int Add(int right,int left){
    
    
return left+right;
}

c++支持函数重载的原因:
c++支持函数重载的原因是因为c++中名字修饰(name Mangling)规则的原因
在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。Name Mangling是一种在编译过程中，将函数、变量的名称重新改编的机制，简单来说就是编译器为了区分各个函数，将函数通过某种算法，重新修饰为一个全局唯一的名称。
C语言的名字修饰规则非常简单，只是在函数名字前面添加了下划线，所以不支持函数重载。
而c++中名字修饰的规则更为复杂(其可能包含参数的名称,参数的类型,参数的作用域等等,各编译器修饰规则不同),所以函数名相同，却可以是不同的函数，所以c++支持函数重载
5引用
概念:引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
注意:

引用在定义时必须初始化
一个变量可以有多个引用
引用一旦引用一个实体，再不能引用其他实体
引用类型必须和引用实体是同种类型的

namespace N {
    
    
	int a = 10;    
	int b = 20;    
	int Add(int left, int right=10) {
    
     
		return left + right; 
	}
	int Sub(int left=10, int right=10) {
    
    
		return left - right; 
	}
}
using namespace std;
int main() {
    
    
//引用的定义,格式:类型& 引用变量名(对象名) = 引用实体；
	int& ra = N::a;   
	cout << N::a<<endl;   //输出10
	ra = 5;         //对a的引用进行修改即对其本身进行修改
	cout << ra<<endl;       //输出5
	cout << N::a<<endl;     //输出5
	return 0; 
}

void TestRef() {
    
       
int a = 10;   
// int& ra;   // 该条语句编译时会出错,未初始化

//定义多个引用
int& ra = a;   
int& rra = a;   
printf("%p  %p  %p\n", &a, &ra, &rra);  
}

常引用

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

引用作为参数
不会发生拷贝,是对被传参对象的本省的操作

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

做返回值

int& TestRefReturn(int& a) {
    
       
a += 10;   
return a;
 }
/*注意(：如果函数返回时，离开函数作用域后，其栈上空间已经还给系统，因此不能
用栈上的空间作为引用类型返回。如果以引用类型返回，返回值的生命周期必须不受
函数的限制(即比函数生命周期长)。
)*/

引用和指针的区别

引用在定义时必须初始化，指针没有要求
引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
没有NULL引用，但有NULL指针
在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占 4个字节)
引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
有多级指针，但是没有多级引用
访问实体方式不同，指针需要显式解引用，引用编译器自己处理
引用比指针使用起来相对更安全
6 内联函数
概念：以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率。
特点：
1.inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

一些简单的c++入门知识

猜你喜欢