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

末蓝、 2023-06-12 13:28 41阅读 0赞

### 文章目录 ###

*   *  求圆的周长和面积
     *  易犯错误模型
 *  C++对C的扩展
 *   *  1. namespace 和 iostream
     *  2. 实用性增强
     *  3. register关键字增强
     *  4. 新增bool类型关键字
     *  5.三目运算符增强
 *  const
 *   *  const 和 define
 *  引用的基础知识
 *   *  变量名：
     *  引用的概念
     *  复杂数据类型引用做函数参数
     *  引用的本质
     *  函数返回值是一个引用

## 求圆的周长和面积 ##

//求圆的周长面积
    //1.面向过程
    #include<iostream>
    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;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA_size_16_color_FFFFFF_t_70 1]

//面向对象
    
    #include <iostream>
    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<iostream>
    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;
    }

![在这里插入图片描述][20191113124946553.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA_size_16_color_FFFFFF_t_70 2]

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

添加成员函数

//易错模型 没有成员函数
    
    #include<iostream>
    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;
    }

![在这里插入图片描述][20191113131216823.png]

# C++对C的扩展 #

## 1. namespace 和 iostream ##

#include<iostream>
    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;
    }

![在这里插入图片描述][20191113142148502.png]

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

## 2. 实用性增强 ##

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

## 3. register关键字增强 ##

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

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

## 4. 新增bool类型关键字 ##

#include<iostream>
    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;
    }

![在这里插入图片描述][2019111315210716.png]

## 5.三目运算符增强 ##

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

#include<iostream>
    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;
    
    }

![在这里插入图片描述][20191113153848930.png]

# const #

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

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

#include<iostream>
    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 <iostream>
    using namespace std;
    
    int main()
    { 
    	int *p = NULL;
    	int const a = 10;
    	//int a = 10;
    	p = (int*) &a;
    	*p = 20;
    	cout << a << endl;
    
    }

![在这里插入图片描述][2019111322272587.png]

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

![在这里插入图片描述][20191114095250349.png]  
//交换

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

#include<iostream>
    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;
    }

![在这里插入图片描述][20191114094659604.png]

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

//复杂数据类型引用做函数参数
    #include<iostream>
    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;

![在这里插入图片描述][20191114103119279.png]

## 引用的本质 ##

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

![在这里插入图片描述][20191114133202955.png]

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

#include<iostream>
    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;
    }

![在这里插入图片描述][20191114133814875.png]

#include<iostream>
    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;
    }

![在这里插入图片描述][20191114135544178.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191113102437518.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191113102448328.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA==,size_16,color_FFFFFF,t_70
[20191113124946553.png]: https://img-blog.csdnimg.cn/20191113124946553.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191113130245414.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA==,size_16,color_FFFFFF,t_70
[20191113131216823.png]: https://img-blog.csdnimg.cn/20191113131216823.png
[20191113142148502.png]: https://img-blog.csdnimg.cn/20191113142148502.png
[2019111315210716.png]: https://img-blog.csdnimg.cn/2019111315210716.png
[20191113153848930.png]: https://img-blog.csdnimg.cn/20191113153848930.png
[2019111322272587.png]: https://img-blog.csdnimg.cn/2019111322272587.png
[20191114095250349.png]: https://img-blog.csdnimg.cn/20191114095250349.png
[20191114094659604.png]: https://img-blog.csdnimg.cn/20191114094659604.png
[20191114103119279.png]: https://img-blog.csdnimg.cn/20191114103119279.png
[20191114133202955.png]: https://img-blog.csdnimg.cn/20191114133202955.png
[20191114133814875.png]: https://img-blog.csdnimg.cn/20191114133814875.png
[20191114135544178.png]: https://img-blog.csdnimg.cn/20191114135544178.png