C++基础 01

1.标准输出：

#include"iostream"	//包含C++的头文件。
using namespace std;	//使用标准的std命名空间（在这个空间里面定义了很多的标准定义）

void main()
{
	cout << "hello C++" << endl;
	//cout 标准输出 黑屏幕
	//左移运算符   在c++中功能改造，运算符重载
	//endl  表示回车换行；
	system("pause");
}

2.面向过程的计算一个圆的面积：

//面向过程的求解一个圆的面积
void main()
{
	double r = 0;
	double s = 0;
	cout << "输入圆的半径";
	cin >> r;//从键盘输一个值赋值给r
	s = 3.14*r*r;
	cout << "圆的面积是：" << s << endl;
	system("pause");
}

3.面向对象的思想计算一个圆的面积，定义类  和  结构体对比

struct Cricle
{
	double r;
	double s;
};

//类的定义是从结构演变而来的，并进行了功能的扩充；
class MyCricle
{
public:
	double m_r;
	double m_s;

	void setR(double r)
	{
		m_r = r;
	}
	double getR()
	{
		return m_r;
	}
	double getS()
	{
		return 3.14*m_r*m_r;
	}
};
//1.抽象类，成员变量和成员函数
//2.实例化类
//3.求解面积：面向过程是加工一个个函数；面向对象是加工一个个类；
//类 是一种数据类型（固定大小内存块的别名），定义类不给分配内存，只有去定义类变量的时候才会分配内存；
void main()
{
	MyCricle c1;
	cout << "请输入圆的半径";

	cin >> c1.m_r;
	cout << "圆的面积是：" << c1.getS() << endl;
	system("pause");
}

4.命名空间的使用和定义

#include"iostream"	//包含C++的头文件。
using namespace std;	//使用标准的std命名空间（在这个空间里面定义了很多的标准定义）
//在iostream中没有引入std命名空间，在此所以要自己写；如果不写则需要显示引入std；

//定义命名空间
namespace nameA {
	int a;
}
namespace nameB {
	int a;
	namespace nameC {
		struct MyStruct
		{
			char * name;
			int age = 20;
		};
	}
}
void main()
{
	using namespace nameA;
	nameA::a = 100;
	cout << nameA::a << endl;
	using namespace nameB;
	nameB::a = 200;
	cout << nameB::a << endl;

	//显示，全路径,如果是命名空间嵌套的话，不要写namespace关键字
	nameB::nameC::MyStruct stu1;
	stu1.age = 30;

	//隐士写法
	using  nameB::nameC::MyStruct;
	MyStruct t;
	t.name = "hahah";
	cout << stu1.age << t.name << endl;
	system("pause");
}

结论：

5. C++对C的增强和扩展

5.1：变量在c中必须定义在开始，而C++可以定义在开始，也可以在需要的时候去定义；

5.2：C中的 register关键字定义变量：意思是把变量直接存放在寄存器中，速度更快。在寄存器中的变量是无法取地址的。但是在C++中是可以取地址的。在c++中如果频繁使用的变量，会做优化，放在寄存器中。register变的失效了。

5.3：struct定义的结构体在c中不认为是一种数据类型，在定义变量的时候必须携带struct;但是在C++中定义结构体变量的时候就不用携带这个关键字了，而且在结构中还可以添加权限关键字，C++对struct关键字进行了功能的增强。

5.4：在C++中新增的关键字：bool 布尔类型；1个字节的内存；要么是1要么是0；你给赋值一个正数或者一个负数，打印出来还是1，都是真；只有0才是假；

5.5 在c中表达式不能做左边的值，表达式的返回值是放在寄存器中的，返回的是一个值；但是在C++中表达式不仅仅可以返回一个值，也可以是一个变量，一块内存，一个指针，变量可以赋值，所以是可以做左值的。总结：左值必须是一个内存空间；

5.6 const关键字在c++中的使用

	const int a=10;  //变量a不能被修改，必须在初始化的时候进行赋值操作。
	const int* a;//表示a所指向的内存空间不能被修改；
	int* const a=NULL;//表示指针变量a不能被修改；初始化的时候就要赋值，以后a就不能在赋值操作了
	const int* const a=NULL;//变量a和a所指向的内存空间都不能被修改。

在c中就是个冒牌货了，通过指针是可以修改其值的。

5.7 const 和#define相同之处：在C和C++中变量是不能作为下标的，不支持这种语法，但是在Linux内核gcc编译器是支持这种语法的；要对变量进行const修饰才可以做下标使用；这种情况和#define a 10；a在做下标使用时一样的，所以const和#define都是在编译的时候进行处理的。宏定义是预处理，编译前替换，没有作用域；

6.引用

变量的别名，一个内存空间可以存在多个别名；是c++的语法范畴；当然引用也可以做函数参数，就不需要赋值了，引用在结构体重也可以不用赋值。但是普通引用必须要初始化；引用也是一种数据类型和指针是一样的，也分配内存的。具体内存自己sizeof一下，int类型的引用站4个字节

引用的内部实现其实就是指针，因此和指针占据内存大小是一样的。

void main()
{
	int a = 100;
	int &b = a;//b就是a的引用，引用也是一种数据类型，通过引用可以操作内存，a的值就是200；
	b = 200;
	cout <<"a是" <<a<<"    b是"<<b<< endl;
	system("pause");
}

7.复杂类型做函数引用

struct MyStruct
{
	char * name;
	int age;
};
void getinfo(MyStruct * ms)
{

}
void getinfo2(MyStruct & ms)
{

}
void getinfo3(MyStruct  ms)
{

}
void main()
{	
	MyStruct ms;
	getinfo(&ms);//去地址扔过去
	getinfo2(ms);//引用扔过去
	getinfo3(ms);//赋值拷贝扔过去，

}

8.函数的返回值是引用的情况

int getinfo()
{
	int a = 11;
	return a;//返回变量的值
}
int& getinfo2()
{
	int a = 12;
	return a;//返回一个引用，一个变量，一个变量的实体，可以用变量去接受，相当于赋值
}
int* getinfo3()
{
	int a = 13;
	return &a;//返回一个指针，一个内存空间，但是这个函数结束的时候就会释放掉
}
void main()
{	
	int a = getinfo();//返回一个变量，赋值
	int b = getinfo2();//返回一个引用，一个实体变量，相当于赋值，相当于返回a；b=a;但是此时a是局部内存空间，会被释放的，用int &b去接受的话会有潜在的问题；
	int * c = getinfo3();//c就指向了一块被释放的内存，野指针；


	//getinfo() = 100;  //这样报错，编译不过去
	getinfo2() = 100;   //相当于a=100；

	printf("a的值%d  b的值%d  c的值%d\n",a,b,*c);
	system("pause");

}

如果返回一个全局变量或者静态，或者局部静态变量的引用，全局的和静态的系统不会自动释放的，所以返回引用是可以的。返回指针也是可以的。