C++基础学习一

双冒号作用域运算符

1.编译器有就近原则，默认选择局部变量

#include <iostream>
using namespace std;

int a = 200;

int test()
{
	int a = 100;
	cout << "a = " << a << endl;//编译器有就近原则，默认选择局部变量
	cout << "a = " << ::a << endl;
	return 0;
}

int main()
{
	test();
	system("pause");
	return 0;
}

命名空间

namespace命名空间主要用途，用来解决命名冲突的问题
1.命名空间下可以放函数，变量，结构体，类
2.命名空间必须定义在全局作用域下，不能再某个函数内
3.命名空间可以嵌套命名空间
4.命名空间是开放的，可以随时往原先的命名空间添加内容
5.无名/匿名命名空间，空间内的成员自动加上static属性
6.命名空间可以起别名

namespace A
{
	int m_B = 100;

	namespace B //3.命名空间可以嵌套	
	{
		int m_B = 200;	
	}
}
int test01()
{
	cout << "作用域B下的m_B是" << A::B::m_B << endl;
	return 0;
}
//4.命名空间是开放的，可以随时在原先的命名空间添加内容
namespace A //此命名空间会和上面的命名空间A进行合并
{
	int m_A = 500;
}
//5.当写了无名命名空间，相当于static int m_C;只能在当前文件中使用
namespace
{
	int m_C = 0;
}
//命名空间可以起别名
namespace verylongname
{
	int m_A = 0;
}
void test02()
{
	namespace shortname = verylongname;
	cout<<verlongname::m_A<<endl;
	cout<<shortname::m_A<<endl;
}

c++对c语言的增强

1.全局变量的检测增强
2.函数检测增强，函数类型增强，返回值检测增强，函数调用参数检测增强
3.类型转换检测增强
4.struct增强，c语言中struct内不可以有函数
5.bool类型增强，c语言没有 bool类型
6.三目运算符的增强，c++返回变量，c语言返回变量的值。
7.const增强,c语言中，const变量是伪变量，编译器是会分配内存，只要有内存的变量都是可以修改的，c++大部分是不会分配内存的如const int b= 100；编译器把b放入符号表中，不放在内存中，符号表中查找对应的键值。c语言中const默认外部链接；c++中默认const是内部链接，只有在当前的文件夹能找到。
如果在c++中想使用，在其他文件中申明时，就需要加上extern关键字
8.const内存分配情况，8.1.对const变量取地址会分配临时内存。
8.2，extern编译器也会给const变量分配内存
8.3，用普通变量初始化const的变量
8.4.自定义数据类型会分配内存。
9.

//1.全局变量检测增强
int a;
int a = 10 //c语言可以编译过，C++中重复定义

//2.函数检测增强，函数类型增强
int getRectS(w, h)//c语言可以编译过，C++提示参数类型和返回值错误
{
}
void test() //C语言可以编译成功，C++函数调用参数检测增强 
{
	getRectS(10, 10, 10)
}
//3.类型转换检测增强 
//如下代码在C中很常见，malloc返回值是void*，万能指针，在c++中编译不过，需要在malloc前加上（char*）
void test01()
{
	char *p = malloc(sizeof(char)*64)
}

//4.c语言中struct不可以加函数
struct A
{
	int m_A;
	void plusA(); //c语言中struct不可以加函数
}

//5.bool类型增强，c语言没有 bool类型
bool flag = true;
void test02()
{
	cout << sizeof(flag) << endl;  //输出1，只是一个标志位，0或1
	flag = 1000;
	//bool类型非0值转为1，
	cout << flag << endl; //输出1
}

//6.三目运算符增强 
void test03()
{
	int a = 10;
	int b = 20;
	(a > b ? a : b) = 100 //此句在c++中正确，c返回的是值中相当于20 = 100因此错误
	//*(a > b ? &a : &b) = 100 c语言可以这样写来修改变量的值
	cout << a<< endl; //10
	cout << b<< endl; //100 c++中返回的是变量b
}

//7.const增强，代码都是在C语言中出现的问题
const int m_A = 10; //受到保护不可以修改
void test04()
{
	const int m_B = 20; //伪常量，不可以用来定义数组
	int *p = (int *)&m_B;
	*p = 200;
	cout << p<< endl;  //200
	cout << m_B<< endl; //200
	int arry[m_B];//会报错，不能用来定义数组
}
//7.const增强，c++中
const int m_A = 10; //受到保护不可以修改
void test04()
{
	const int m_B = 20; //常量，可以用来定义数组
	int *p = (int *)&m_B;
	*p = 200;
	cout << p<< endl;  //200，p指向的是临时的地址，m_B的值在符号表中，无法修改
	cout << m_B<< endl; //20
	int arry[m_B];//不报错，用来定义数组
}
//7.1const增强，c语言中const默认外部链接，
extern const int a;//告诉编译器a在外部
//7.2c++中默认const是内部链接，只有在当前的文件夹能找到。
如果在c++中想使用，在其他文件中申明时，就需要加上extern关键字

引用

1.引用的本质就是指针常量，所以创建引用时必须要初始化。
int &ret = a； //编译器会自动转换为int* const ret = &a
ret = 20; //内部发现ret是引用自动转换为*ret = 20

//1.引用的基本语法，type &别名 = 原名
void test01()
{
	int a = 200;

	int &b = a;
	b = 20;
	cout << "a = " << a << endl;
	cout << "a = " << a << endl;
}
//2.引用必须初始化
void test02()
{
	//int &a;引用必须初始化
	int a = 10;
	int &b = a;//引用初始化后不可以修改了
	int c = 20;
	b = c;   //这里是赋值
}

//3.对数组建立引用
void test03()
{
	int arry[10];
	for (int i = 0; i < 10; i++)
	{
		arry[i] = i;
	}
	//给数组起别名
	int(&parry)[10] = arry;
	for (int i = 0; i < 10; i++)
	{
		cout << parry[i] << endl;
	}
	cout << endl;

	//第二种方式
	typedef int(ARRYTYPE)[10]; //ARRYTYPE是一个有10个int元素的数组
	ARRYTYPE &PA = arry;
}