第一周学习报告

  按照给到的课程我应该从c++的类和对象开始学，但我看见作业题之后发现还有函数重载，所以我往回看了函数重载的那几节，在看完函数重载之后发现还有个引用需要用到，所以我把引用到类和对象的几节课也学了。

  下面来分享下我这一周学到的内容

1.引用

（1）用法 ：数据类型 &别名=原名

（2）注意事项：

        1）引用必须初始化（如int &c为错误）

        2）初始化之后的值不能更改，但可以赋值（如不能同时有         int &c=a ； int &c=b） 

        3）int &c=a；c=b；此为赋值，不是更改引用

（3）引用可以做函数参数，相当于简化指针修改参数

（4）引用做函数返回值（如int& test（））

        注意：不要返回局部变量引用，返回局部变量会使返回值出错，在返回的第一次使用是还是正确的，但在返回值第二次使用时就会出现错误。因为返回值中的局部变量内存已经释放，所以整个返回值也会改变。需要使用静态变量引用

        用法：引用函数可以作为左值

                （如int& a=test（）；test（）=1000）

（5）本质：c++中内部实现的一个指针常量

                若是int& ref=a；则会自动转化为int* const ref=&a；指针的指向不能够修改。

（6）常量引用

        作用：修饰形参，防止误操作

        在参数列表中加入const修饰形参可以防止形参发生改变，加入const之后在函数中就会有只读的状态，而不能发生改变。

        注意 （int& ref=10；）为错误，引用本身需要一个合法的内存空间。但是（const int& ref=10；）为正确，因为编译器会优化代码，会自动写成（int a=10；const int& ref=a；）

        加入const之后就会无法修改变量的值

2.函数默认参数

        语法：返回值类型 函数名 （参数=默认值）{} 

        注意：1)如果某个位置参数有默认值，那么这个位置往后，从左到右都必须有默认值。

                   2)如果函数声明有默认值，函数的实现就不能再有默认值。

                   3)如果传入的数据中没有函数的参数，就会使用默认值

                   (如int func（int a，int b=20）{}，那么在主程序中有a=func（10）；也可以运行）

3.函数占位参数

        语法：返回值类型  函数名  （数据类型）{} 

                如 void func(int a,int){}         viod func(int a,int=10){}

4.函数重载

（1）概述

        作用：函数名可以相同，提高复用性

        满足条件：1）同一作用域下 2）函数名称相同 3）函数参数类型不同 或者 个数不同 或者 顺序不同

        注意：函数的返回值不能作为函数重载的条件

（2）注意事项

        1）引用作为重载的条件时注意引用中的const的用法，没有const不能直接传入定值

        2）函数重载尽量避免写默认参数

5.类和对象

对象分为三大特性：封装，继承，多态

（1）封装  

意义：

1）将属性和行为作为一个整体，表现生活中的事物

        语法：class 类名{访问权限：属性/行为}；

示例1：设计一个圆类，求圆的周长

#include<iostream>
using namespace std;
class circle
{
public:
	int r;
	double c()
	{
		return 2*3.14*r;	
	} 
};
int main()
{
	circle c1;
	c1.r=10;
	cout<<c1.c()<<endl;
	return 0;
}

  示例二：设计一个学生类

#include<iostream>
using namespace std;
class Student{
public:
	string name;
	int id;
	void SetName(string n)
	{
		name=n;
	}
	void setId(int i)
	{
		id=i; 
	}
	void print()
	{
		cout<<"name:"<<name<<"ID:"<<id<<endl;
	}
}; 
int main()
{
	Student l;
	l.SetName("坤坤");
	l.setId(250);
	l.print();
	return 0;
}

2）访问权限

{1}public 公共权限 类内可以访问，类外可以访问

{2}protected 保护权限 类内可以访问，类外不可以访问 儿子可以访问父亲中的保护内容

{3}private 私有权限 类内可以访问，类外不可以访问 儿子不可以访问父亲中的私有内容

struct与class区别

在c++中struct与class唯一的区别就在于默认的访问权限不同

struct的默认权限为公共        class的默认权限为私有

将成员属性设为私有

优点1：可以控制读写权限

优点2：对于写权限，我们可以检测数据的有效性

练习案例1：设计立方体类（Cube）

求立方体的面积和体积

用成员函数判断两个立方体是否相等

#include<iostream>
using namespace std;
class cube{
private:
	int L,H,W;
public:
	void stel(int l) 
	{
		L=l;
	}
	void seth(int h)
	{
		H=h;
	}
	void setw(int w)
	{
		W=w;
	}
	int getl()
	{
		return L;
	}
	int getw()
	{
		return W;
	}
	int geth()
	{
		return H;
	} 
	int S()
	{
		return 2*(L*H+L*W+H*W);
	} 
	int V()
	{
		return L*H*W;
	}
	bool sc(cube &c)
	{
		if(c.geth()==H&&c.getl()==L&&c.getw()==W) return true;
	}//  成员函数 
};
int main()
{
	cube c1,c2;
	c1.seth(10);
	c1.setw(10);
	c1.stel(10);
	c2.seth(10);
	c2.setw(10);
	c2.stel(10);
	if(c2.sc(c1)) cout<<"是"<<endl;
	return 0;
}

 对象的初始化和清理

1）构造函数和析构函数（没有写也会自动运行成空实现）

        构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用

        析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作

2）构造函数语法：类名（）{}

        构造函数，没有返回值也不写void

        函数名称与类名相同

        构造函数可以有参数，因此可以发生重载

        程序在调用对象时会自动调用构造，无须手动调用，而且只会调用一次

构造函数的分类以及调用

两种分类方式：

        按参数分为：有参构造和无参构造

        按类型分为：普通构造和拷贝构造

        拷贝构造形式  （在类内使用） 类名（const 类名 &变量）{}//拷贝另一个对象上的数据，并且不会改变要拷贝的对象的数据

三种调用方式：

        括号法（常用）

                类名 变量;// 默认构造函数调用   Person p1; 

                类名 变量(常数);//有参构造函数        Person p1(10);

                类名 变量(变量);//拷贝构造函数        Person p1(p2);

        显示法

                类名 变 量;// 默认构造函数调用        Person p1;

                类名 变量=类名(常数);//有参构造函数        Person p1=Person(10);

                类名 变量=类名(变量);//拷贝构造函数        Person p1=Person(p2);

                类名(常数);//匿名对象 特点：当前执行结束后，系统会立即回收掉匿名对象        Person(10)

                //类名(变量);//不要利用拷贝构造函数 初始化匿名对象        Person(p2);

        隐式转换法

                类名 变量=常量;//相当于写了  类名 变量=类名(常量); 有参构造        Person p1=10;

                类名 变量=变量//拷贝构造               Person p1=p2;

例题

定义类Date的私有数据成员year、month和day，分别表示年、月、日，它们都是int数据类型。

定义类Date的公有默认构造函数Date，使Date对象的默认值为：year=1,month=1,day=1。

定义类Date的公有带参构造函数Date(int y,int m,int d)，把数据成员year、month和day分别初始化为参数y,m,d的值。

完成Date类的公有成员函数void print()的类外定义，使其以“×年×月×日”的格式将Date对象的值输出到屏幕上。

编写主函数，定义Date类对象national_day并向其发送print消息，

        使程序运行结果示例如下:

                  1949年10月1日

#include<iostream>
using namespace std;
class Date{
private:
	int year,month,day;
public:
	Date()//无参构造
	{
		year=1;
		month=1;
		day=1;
	}
	Date(int y,int m,int d)//有参构造
	{
		year=y;
		month=m;
		day=d;
	}
	void print()
	{
		cout<<year<<"年"<<month<<"月"<<day<<"日"<<endl;
	}
};
int main()
{
	Date national_day(1949,10,1);//括号法
	national_day.print();
	return 0;
} 

3）析构函数语法 ~类名（）{}

        析构函数，没有返回值也不写void

        函数名称与类名相同，在名称前加上~符号

        析构函数不可以有参数，因此不可以发生重载

        程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次

4）拷贝构造函数

        使用一个已经创建完毕的对象来初始化一个新的对象

               在类内中用法：类名（const 类名 & 变量）{} //Person（const Person & p）{m_Age=age;}

               在主程序中用法： 类名 变量（变量）//Person p2(p1);

        值传递的方式给函数参数传值

                用法：void a(Person p){}

                           void test(){Person p; a(p);} //在主程序中调用text()

        以值方式返回局部对象

                用法：Person a(){Preson p1;return p1;}

                           void test(){Person p=a();}//在主程序直接调用test();

5）构造函数的调用规则

        在默认情况下，c++编译器至少给一个类添加3个函数：默认构造函数（无参，函数体为空） 

                                                                                               默认析构函数（无参，函数体为空）

                                                                                               默认拷贝构造函数，对属性进行值拷贝

        如果用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造

        如果用户定义拷贝构造函数，c++不会再提供其他构造函数

                        在不写拷贝构造函数的情况下主程序中也能使用拷贝函数//Person p1(p2);

6）浅拷贝和深拷贝（与指针有关）

        堆区：有程序员自己开辟分配的一个内存空间，由程序员分配释放，若程序员不释放，程序结束时有操作系统回收，在c++中主要利用new在堆区中开辟内存 用法：new 变量类型（原来的数据）

        浅拷贝：简单的赋值拷贝操作

                系统中自动调用的拷贝构造函数，直接让两个值相等。但如果使用堆区进行操作时，我们需要再析构函数中进行手动的内存清理  清理代码 :if(变量!=NULL) {detele 变量;变量=NULL}

                此时若直接使用浅拷贝就会出现两次内存清理在同一个位置，会使程序运行出错，这就需要用到深拷贝

        深拷贝：在堆区中重新申请空间，进行拷贝操作

                在拷贝构造函数中讲每一个变量的值都传到一个不同的堆区之中，保证在内存释放时可以正常运行