30天学习C++从入门到入土 --- Day01

求圆的周长和面积

//求圆的周长面积
//1.面向过程
#include
using namespace std;

int main()
{
	double r = 0;
	double pi = 3.14;
	cout << "Please enter r :" << endl;
	cin >> r;

	double c = 0, s = 0;
	c = 2 * pi * r;
	s = pi * r * r;
	cout << "周长是：" << c << endl
		<< "面积是：" << s << endl;
}

//面向对象

#include 
using namespace std;


//定义一个circle类 类的抽象
class circle {
private:
	double radius = 0;//定义成员变量 / 属性
	double pi = 3.14;
public:
	void Set_radius(double r)//定义成员函数
	{
		radius = r;
	}
	double Get_radius()
	{
		return radius;
	}
	double Grith()
	
		return  2 * pi * radius;
	}
	double Area()
	{
		return pi * radius * radius;
	}
};

//实例化
int main()
{
	circle A, B;//类创建对象
	A.Set_radius(2);//对象调用类的成员函数
	B.Set_radius(3);
	cout << "圆A的周长是：" << A.Grith() << endl;
	cout << "圆A的面积是：" << A.Area() << endl;
	cout << "圆B的周长是：" << B.Grith() << endl;
	cout << "圆B的面积是：" << B.Area() << endl;
}

易犯错误模型

//易错模型 没有成员函数

#include
using namespace std;

class circle
{
//只有成员变量，没有成员函数
public:
	double r ;
	double pi = 3.14;
	double area = pi * r * r;
};

int main()
{
	circle c1;
	cout << "Please enter your r:" << endl;
	cin >> c1.r;
	cout << c1.area << endl;//没有执行pi * r * r 只是从变量area取值

	return 0;
}

因为初始化的时候r是一个随机值，造成area的值是一个乱码

添加成员函数

//易错模型 没有成员函数

#include
using namespace std;

class circle
{
//只有成员变量，没有成员函数
public:
	double r ;
	double pi = 3.14;
	double area = pi * r * r;
	//添加成员函数
	double getArea()
	{
		area = pi * r * r;
		return area;
	}

};

int main()
{
	circle c1;
	cout << "Please enter your r:" << endl;
	cin >> c1.r;
	//函数调用
	c1.getArea();
	//没有执行pi * r * r 只是从变量area取值
	//在类型定义的时候 area 里面就已经有了一个大的垃圾值
	cout << c1.area << endl;

	return 0;
}

C++对C的扩展

1. namespace 和 iostream

#include
using namespace std;
//命名空间的定义
namespace namespaceA
{
	int a = 10;
}

namespace namespaceB
{
	int a = 30;
	//命名空间的嵌套
	namespace namespaceC
	{
		struct Teacher
		{
			char name;
			int age;
		};
	}
}

int main()
{
	//命名空间的使用
	cout << namespaceA::a << endl;
	cout << namespaceB::a << endl;

	namespaceB::namespaceC::Teacher t;
	t.age = 40;
	//using namespaceB::namespaceC::Teacher;
	//Teacher t;
	//t.age = 40;
	cout << t.age << endl;
}

c++标准为了和C区别开，也为了正确使用命名空间，规定头文件不使用后缀.h。

2. 实用性增强

C语言中的变量都必须在作用域开始的位置定义！！
C++中更强调语言的“实用性”，所有的变量都可以在需要使用时再定义。

3. register关键字增强

register关键字 请求编译器让变量a直接放在寄存器里面，速度快

在c语言中 register修饰的变量 不能取地址
在C++中依然支持register关键字
C++编译器有自己的优化方式，不使用register也可能做优化
C++中可以取得register变量的地址

4. 新增bool类型关键字

#include
using namespace std;

int main()
{
	//占用内存空间
	//告诉编译器分配一个字节的内存空间
	cout << "sizeof(bool)" << sizeof(bool) << endl;


	//bool变量只能为 1 或 0；
	bool b0 = 0;
	bool b1 = 10;
	bool b2 = -10;
	bool b3 = true;
	bool b4 = false;
	cout << "b0 : " << b0 << endl;
	cout << "b1 : " << b1 << endl;
	cout << "b2 : " << b2 << endl;
	cout << "b3 : " << b3 << endl;
	cout << "b4 : " << b4 << endl;

	return 0;
}

5.三目运算符增强

C中 返回的是变量的值 ，不能做左值（当左值的条件： 有一定的内存空间）
C++ 中返回的是变量的本身，可以做指针

#include
using namespace std;

int main()
{
	int a = 10;
	int b = 20;
	
	//(a > b ? a : b)返回的是变量的本身
	//a < b  把30赋值给b 
	//如何在C中完成C++中的操作
	//返回内存空间 内存首地址 指针
	//*(a > b ? &a : &b) = 30;
	(a > b ? a : b) = 30;
	cout << "a: " <<a << endl;
	cout << "b: " <<b << endl;
	return 0;

}

const

const 修饰的是指针变量本身 还是 指针所修饰的内存空间

const是定义常量，表示只能只读

#include
using namespace std;

struct Teacher
{
	char name;
	int age;
};

//指针所指向的内存空间不能被修改
int operatorTeacher01(const Teacher* pt)
{
	//pt.age = 10;
	return 0;
}

//指针变量不能被修改，指针所指向的内存空间可以被修改
int operatorTeacher02(Teacher* const pt)
{
	pt->age = 10;
	//pt = NULL;
	return 0;
}
int operatorTeacher03(const Teacher* const pt)
{
	//pt->age = 10;
	//pt = NULL;
	cout << pt->age << endl;
	return 0;
}

int main()
{
	Teacher t;
	t.age = 20;
	operatorTeacher03(&t);
	cout << "hello" << endl;

}

C语言中的const是冒牌货 可以通过指针来修改

#include 
using namespace std;

int main()
{
	int *p = NULL;
	int const a = 10;
	//int a = 10;
	p = (int*) &a;
	*p = 20;
	cout << a << endl;

}

C语言中的const变量
C语言中const变量是只读变量，有自己的存储空间
C++中的const常量
可能分配存储空间,也可能不分配存储空间
当const常量为全局，并且需要在其它文件中使用
当使用&操作符取const常量的地址

const 和 define

void fun1()
{
	#define a 10;
	int const b = 10;
}

void fun2()
{
	cout << a;
	//cout << b << endl;
}

int main()
{
	fun1();
	fun2();
	return 0;
}

const常量是由编译器处理的，提供类型检查和作用域检查
宏定义由预处理器处理，单纯的文本替换

引用的基础知识

变量名：

• 实质上是一段连续的内存空间的别名，是一个门牌号
• 程序通过变量来申请并命名内存空间
• 通过变量的名字可以使用存储空间
• 普通引用必须要初始化
• 引用做函数形参不需要初始化

引用的概念

a. 在C++中新增了引用的概念
b. 引用可以看作是一个已定义变量的别名
c. 语法：Type& name = var;

#include
using namespace std;

int main()
{
	int a = 19;
	int& b = a;
	//int& c; //引用必须要初始化
	b = 20;//相当于把a 改成20

	cout << " a:" << a << endl;
	cout << " m:" << b << endl;

	a = 30;//相当于把b也改成30  a 就是b  b 就是  a;

	cout << " a:" << a << endl;
	cout << " m:" << b << endl;
	
	return 0;

}

//交换

引用的意义：
1）引用作为其它变量的别名而存在，因此在一些场合可以代替指针
2）引用相对于指针来说具有更好的可读性和实用性

#include
using namespace std;

void swap01(int a, int b)
{
	int t;
	t = a;
	a = b;
	b = t;
}

void swap02(int* a, int* b)
{
	int t;
	t = *a;
	*a = *b;
	*b = t;
}

//a就是x的别名， b就是y的别名
//引用做函数形参不需要初始化
void swap03(int& a, int& b)
{
	int t;
	t = a;
	a = b;
	b = t;
}

int main()
{
	int x = 10;
	int y = 20;
	swap01(x ,y);
	cout << "x :" << x << endl
		 << "y :" << y << endl;
	cout << endl;

	swap02(&x, &y);
	cout << "x :" << x << endl
		 << "y :" << y << endl;
	cout << endl;

	swap03(x, y);
	cout << "x :" << x << endl
		 << "y :" << y << endl;

	return 0;
}

复杂数据类型引用做函数参数

//复杂数据类型引用做函数参数
#include
using namespace std;

struct Teacher
{
	char name;
	int age;
};

void printT01(Teacher *tP)
{
	cout << tP->age << endl;
}
//tP是t 的别名 ，这里修改 t 的值也会改变
void printT02(Teacher& tP)
{
	tP.age = 40;
	//cout << tP.age << endl;
	
}
//tP和t是两个不同的变量
void printT03(Teacher tP)
{
	tP.age = 45;
	//cout << tP.age << endl;
	//在这里修改tP不会修改t的值
	
}

int main()
{
	Teacher t;
	t.age = 30;
	printT01(&t);

	printT03(t); //tP是形参 相当于copy一份t的数据给tP  ----》 tP  = t
	cout << "t.age:" << t.age << endl;
	
	printT02(t); //tP是t的别名
	cout << "t.age:" << t.age << endl;

引用的本质

void modify01(int& a1)
{
	a1 = 5;
}

void modify02(int* const a1)
{
	*a1 = 15;
}
int main()
{
	int a = 10;
	modify01(a);//函数的引用不需要我们分配内存空间
	cout << a << endl;

	int b = 20;
	modify02(&b);//如果是指针 需要手动的去取实参的地址
	cout << b << endl;
}

间接赋值成立的三个条件

1. 定义两个变量 （一个实参一个形参）
2. 建立关联 实参取地址传给形参
3. *p形参去间接的修改实参的值

void  modify(int* p)//*p间接修改实参值
{
	*p = 100;
}

int main()
{
	int a = 10;
	int* p = NULL;//定义两个变量 一个实参一个形参
	//p = &a;
	modify(&a);//建立关联 把实参的地址传递给形参
	cout << a << endl;
}

引用在实现上，只不过是把：间接赋值成立的三个条件的后两步和二为一
//当实参传给形参引用的时候，只不过是c++编译器帮我们程序员手工取了一个实参地址，传给了形参引用（常量指针）

函数返回值是一个引用

当函数返回值为引用时
若返回栈变量
不能成为其它引用的初始值
不能作为左值使用

#include
using namespace std;

int fun1()
{
	int a1 = 10;
	return a1;
}
int& fun2()
{
	int a2 = 20;
	return a2;
}

int main()
{
	int a = 0;
	a = fun1();
	cout << a << endl;
	a = fun2();
	cout << a << endl;
	//int& a = fun2();//若返回栈变量不能做其他引用的初始值
	//cout << a << endl;


	cout << "hello" << endl;
	return 0;
}

若返回静态变量或全局变量
可以成为其他引用的初始值
即可作为右值使用，也可作为左值使用

#include
using namespace std;
//返回变量的值
int fun1()
{
	static int a1 = 10;
	return a1;
}
//返回变量本身
int& fun2()
{
	static int a2 = 20;
	return a2;
}

int main()
{
	int a = 0;
	int b = 0;
	a = fun1();
	cout << a << endl;
	b = fun2();
	cout << b << endl;
	int& c = fun2();
	cout << c << endl;
	return 0;
}

#include
using namespace std;
//返回变量的值
int fun1()
{
	static int a1 = 10;
	return a1;
}
//返回变量的本身
int& fun2()
{
	static int a2 = 20;
	a2++;
	cout << a2;
	return a2;
}

int main()
{
	fun2() = 100;//函数返回值是一个引用，并且当左值
	cout << endl;
	fun2();
	cout << endl;
	int c = fun2();// 函数返回值当右值
	return 0;
}