[C++的类和对象一]

一.类的基本知识

1.1类的空间大小

class Data
{
private:
    int num;      //成员数据，占类的空间大小 4B
public:
    void setNum(int data)   //成员函数，不占类的空间大小
    {
        num=data;
    }
}

1.2成员函数在类内声明在内外定义

class DATE
{
private:
	int num;
public:
	void setNum(int Num);
	int getNum();
};

void DATE::setNum(int Num)
{
	num = Num;
}

int DATE::getNum()
{
	return num;
}

1.3类的定义在头文件，成员函数在cpp文件中实现

//在data.h文件中定义类
class Data
{
private:
	int num;
public:
	void setNum(int n);
	int getNum();
};

//在data.cpp文件中定义类的成员函数
#include "data.h"
void Data::setNum(int n)
{
	num = n;
}

int Data::getNum()
{
	return num;
}

//在main.cpp中调用
#include<iostream>
#include"data.h"

using namespace std;

int main()
{
	Data ob;
	ob.setNum(200);
	cout << ob.getNum << endl;
}

二.构造和析构函数

2.1构造函数和析构函数的概述

        构造函数和析构函数，这两个函数将会被编译器自动调用，构造函数完成对象的初始化动作，析构函数在对象结束的时候完成清理工作。

• 对象的初始化和清理工作是编译器强制我们要做的事情，即使不提供初始化操作和清理操作，编译器也会增加默认操作，但是这个默认初始化操作不会做任何事：
• 构造函数：实例化对象时系统自动调动
• 析构函数：对象释放的时候系统自动调用

2.2构造和析构函数的定义

构造函数：析构函数函数名和类目相同，没用返回值（void也不行），但可以有参数，可以重载。

析构函数：析构函数函数名是在类名前加“~”组成，没用返回值（void也不行），不能有参数，不能重载。

class stu
{
public:
	int num;
	stu()     //构造函数（无参的构造）
	{
		num = 0;
	}
	stu(int n)  //构造函数（有参的构造）
	{
		num = n;
	}
	~stu()
	{
		cout << "析构函数" << endl;
	}
};

2.2构造函数的分类及调用

分类：

按参数类型：分为无参构造函数和有参构造函数

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

调用：

class stu
{
public:
	int num;
	stu()     //构造函数（无参的构造）
	{
		num = 0;
	}
	stu(int n)  //构造函数（有参的构造）
	{
		num = n;
	}
	~stu()
	{
		cout << "析构函数" << endl;
	}
};

int main()
{
	stu ob1;      //无参调用，默认构造函数（隐式调用）
	stu ob2 = stu();   //无参调用（显式调用）
	stu ob3(10);		//有参调用（隐式调用）
	stu ob4=stu(10)		//有参调用（显式调用）
    stu(20);            //匿名对象，该语句结束后，对象立即释放
}

2.3拷贝构造函数

用一个对象去初始化另一个对象

class stu
{
public:
	int num;
	stu()     //构造函数（无参的构造）
	{
		num = 0;
	}
	stu(int n)  //构造函数（有参的构造）
	{
		num = n;
	}
	~stu()
	{
		cout << "析构函数" << endl;
	}
	stu(const stu &ob)  //拷贝构造函数
	{
		num = ob.num;
	}
};

int main()
{
	stu ob1(10);
	cout << "ob1的num" << ob1.num << endl;
	stu ob2(ob1);         //隐式调用
	stu ob3 = stu(ob1);		//显式调用
	stu ob4 = ob1;			//隐式转换调用
	cout << "ob2的num" << ob2.num << endl;
	cout << "ob3的num" << ob3.num << endl;
	cout << "ob4的num" << ob4.num << endl;
}

注意：

1.只用当用旧对象初始化新对象时，才会调用拷贝构造函数。

stu ob1(10);
stu ob2;
ob2=ob1;    //不会调用拷贝构造函数，单纯的对象赋值操作

2.不能使用拷贝构造函数初始化匿名对象

stu ob1(10);
stu (ob1);    //错误

2.4构造函数的调用规则

系统会对任何一个类提供3个函数成员：1.默认构造函数（空） 2.默认析构函数（空） 3.默认拷贝函数（浅拷贝）

1. 如果用户提供了有参构造，将屏蔽系统的默认构造
2. 如果用户提供了有参构造，不会屏蔽系统的默认拷贝函数
3. 如果用户提供了拷贝构造函数，将屏蔽系统的默认构造函数、默认拷贝构造函数

总结：用户一般要实现：无参构造、有参构造、拷贝构造和析构。

2.5深拷贝和浅拷贝

浅拷贝：同一类型的对象之间可以赋值，使得两个对象的成员变量的值相同，两个对象任然是独立的两个对象，这种情况被称为浅拷贝，一般情况下，浅拷贝没有任何副作用，但当类中有指针，并且指针指向动态分配的内存空间，析构函数做了动态内存释放的处理，会导致内存问题。

深拷贝：当类中有指针，并且此指针有动态分配空间，析构函数做了释放处理，往往需要自定义拷贝构造函数，自行给指针分配动态空间。

Person(const Person& person)
{
    pName = (char*)malloc(strlen(person.pName) + 1);
    strcpy(pName, person.pName);
    mAge = person.mAge;
}

PS.

1.malloc()函数

功能：申请堆内存

所需头文件：stdlib.h

函数原型：void *malloc(size_t,size)

参数：size：所申请的一块内存的下，单位是字节

返回值：成功——指向分配好的堆内存

              失败——指向NULL

2.calloc()函数

功能：同上

头文件：同上

函数原型：void *calloc(size_t count ,size_t size)

参数：size：同上

           count：所申请的堆内存的块数，所用的内存块是连续分布的，无间隔

返回值：同上