【C++笔记---1】(C++入门概念)

一.C++关键字
C++总计63个关键字，C语言32个关键字
关键字详解: https://www.runoob.com/w3cnote/cpp-keyword-intro.html.
二.C++之命名空间

C++在之后的学习中会大量使用变量、函数和类的名称将都存在于全局作用域中，为了对标识符的名称进行本地化，以避免命名冲突或名字污染便诞生了namespace关键字

1.命名空间的定义

//(1). 命名空间普通定义
namespace A // A为命名空间的名称
{
	// 命名空间中,可以定义变量和定义函数
	int a;
	int Max(int a, int b)
	{
		return a > b ? a : b;
	}
}

/(2). 命名空间可以嵌套
namespace A //A命名空间中可以嵌套B命名空间
{
	int a;
	int b;
	int Max(int x1, int x2)
	{
		return x1 > x2 ? x1 : x2;
	}
	namespace B
	{
		int c;
		int d;
		int Min(int x3, int x4)
		{
			return x3 < x4 ? x3 : x4;
		}
	}
}

//(3). 在一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
namespace C
{
	int Max(int a, int b)
	{
		return a > b ? a : b;
	}
}
namespace C
{
	int Min(int a, int b)
	{
		return a < b ? a : b;
	}
}

2.命名空间的使用

//(1).命名空间后跟作用域限定符（::）
int main()
{
	printf("%d\n", A::a);
	return 0;
}

//(2)使用using将命名空间中成员引入
using A::b;
int main()
{
	printf("%d\n", A::a);
	printf("%d\n", b);//因为开头已经引入b，所以可以直接输出
	return 0;
}

//(3)使用using namespace 加命名空间名称引入
using namespce A;
int main()
{
	printf("%d\n", A::a);   //可以用作用域限定引入成员
	printf("%d\n", b);      //可以直接引入成员变量
	Max(10,20);             //可以直接引入成员函数
	return 0;
}

三.C++输入和输出

使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含< iostream >头文件以及std标准命名空间；使用C++输入输出更方便，不需增加数据格式控制，比如：整型–%d，字符–%c。

#include<iostream>
using namespace std;
int main()
{
	int a;
	cout << "Hello world!!!" << endl;//cout和endl可以看作C语言中"printf"和"\n"
	cin >> a;                        //输入a的值    
	return 0;
}

四.缺省参数

缺省参数是声明或定义函数时为函数的参数指定一个默认值。

缺省参数的分类

//(1)全缺省参数
void TestFunc(int a = 10, int b = 20, int c = 30)//函数中每个参数都会给出默认值
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

//半缺省参数
//void TestFunc(int a=10, int b, int c = 20) （错误）
void TestFunc(int a, int b = 10, int c = 20)//半缺省参数必须从右往左依次来给出，不能间隔着给
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

缺省参数不能在函数声明和定义中同时出现，缺省值必须是常量或者全局变量，C语言不支持
五.函数重载
C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同，而C语言不支持重载。
此处重点记录为什么C语言不支持重载，而C++可以：gcc的函数修饰后名字不变。而g++的函数修饰后变成【Z+函数长度+函数名+类
型首字母】，C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。

extern “C”：C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern “C”，该函数便可以用C语言规则来编译

六.引用

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

引用定义

void Test()
{
	int a = 10;
	int& b = a;//<====类型& 引用变量名(对象名) = 引用实体；
	printf("%p\n", &a);
	printf("%p\n", &b);
}

引用特性

void Test()
{
	int a = 10;
	int b = 20;
	// int& b;     //(错误)引用在定义时必须初始化
	int& c = a;
	int& d = a;    //一个变量可以有多个引用
	//int& c = b;  //(错误)引用一旦引用一个实体，不能引用其他实体
}

//--------------------------------------------
//数组引用
int ar[10] = { 0 };
int(&br)[10] = ar;   //此处()很重要
//--------------------------------------------
//指针引用
int *a = &b;
int* &c = a;         //*号位置帮助理解
//--------------------------------------------
//常引用
const int a = 10;
int &b = a;          //b不能引一个常量

int a = 10;
const int &b = a;    //常量不能引用变量

const int a = 10;    //正确版本
const int &b = a;
//--------------------------------------------
//作参数
int swap(int &a, int &b) //传引用
{
	int tmp = a;
	a = b;
	b = tmp
}
int swap(int *a, int *b)//值传递
{
	int tmp = *a;
	*a = *b;
	*b = tmp
}
//值传递的效率远不如传引用
//--------------------------------------------
//作返回值
int& Mul(int a, int b)
{
	//static int c = c * b;   静态变量只会被定义一次，所以输出为200
	int c = a * b;
	return c;
}
int main()
{
	int& cur = Mul(10, 20);
	Mul(30, 40);
	cout << "Mul(10, 20) is :" << cur << endl;   //输出为1200 
	return 0;
}
//这里需要注意如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，
//如果已经还给系统了，则必须使用传值返回。

引用和指针的不同点:

1. 引用在定义时必须初始化，指针没有要求
2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可在任何时候指向任何一个同类型实体
3. 没有NULL引用，但有NULL指针
4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
6. 有多级指针，但是没有多级引用
7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
8. 引用比指针使用起来相对更安全

七.auto关键字

auto是一个类型声明时的“占位符”，编译器在编译期会将auto推导出变量实际的类型

//--------------------------------------------
void TestAuto()
{
	int x = 10;
	//auto b;                 //(错误) 必须初始化
	int ar[10] = { 0 };
	auto br = ar;            // br类型为指针不是数组
	auto a = &x;            //类型为 int*
	auto* b = &x;           //类型为 int
	auto a = 10, b = 20;    // 在同一行定义多个变量，但类型必须相同
	//auto c = 30, d = 4.0;   // (错误) c和d的初始化类型不同
}
//--------------------------------------------
void  Test(auto a)          //(错误) auto不能作形参 
{
	int ar[] = { 10,20,30 }; 
	auto br[] = { 40,50,60 };//(错误) auto不能声明数组
}

八.for循环小记
此处for循环是基于范围的for循环,就是第一个元素和最后一个元素的范围

void Test()
{
	int ar[] = { 1, 2, 3 };
	for (int i = 0; i < sizeof(ar) / sizeof(ar[0]); ++i)
		cout << ar[i] << endl;
	for (auto e : ar)                 //两种语句等价，范围内用于迭代的变量：迭代的范围
		cout << e << endl;            //可以用continue来结束本次循环，也可以用break来跳出整个循环。
}

努力更新…