c++基础

1：类和对象的基础知识，如类的定义，访问限定符，面向对象封装性，对象的大小计算等等。 

c++基础：

1： 类

     在c++中，用 "类" 来描述 "对象",类就可以看做是对相似事物的抽象, 找到这些不同事物间的共同点。这些对象的行为，就是函数。

 类是属于用户自定义的数据类型, 并且该类型的数据具有一定的行为能力, 也就是类中说描述的方法。

类的定义：

 C++中使用关键字 class 来定义类, 其基本形式如下:

class 类名
{
public:
	//公有的行为或者属性;
private:
	//私有的行为或属性;
	
};

   public 与private 为属性/方法限制的关键字, private 表示该部分内容是私密的, 不能被外部所访问或调用, 只能被本类内部访问; public 表示公开的属性和方法, 外界可以直接访问或者调用。

   一般来说类的属性成员都应设置为private, public只留给那些被外界用来调用的函数接口, 但这并非是强制规定, 可以根据需要进行调整;

举个例子：

class Data
{
public:
	void Display(int x,int y);
	void Data();

private:
	int _year;
	int _month;
	int _day;
};

   上面的定义示例中我们只是定义了这个类的一些属性和方法声明, 并没有去实现它, 类的实现就是完成其方法的过程。类的实现有两种方式, 一种是在类定义时完成对成员函数的定义, 另一种是在类定义的外部进行完成。

1在类定义时定义成员函数：

#include <iostream>

using namespace std;

class Date
{
public:
	void Display()
	{
		cout << _year << "_ " << _month << "_ " << _day << endl;
	}
	void Dae(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	d1.Dae(2017, 5, 4);
	d1.Display();
	system("pause");
	return 0;
}

运行输出：

2.在类外定义成员函数

  返回类型 类名::成员函数名(参数列表)
        {
            //函数体
        }

class Date
{
public:
	void Display();

	void Dae(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	d1.Dae(2017, 5, 4);
	d1.Display();
	system("pause");
	return 0;
}

void  Date::Display()
{
	cout << _year << "_ " << _month << "_ " << _day << endl;
}

这段程序中，对Display函数在类外定义。

访问限定符：

public     

表示公开的属性和方法, 外界可以直接访问或者调用

private

表示该部分内容是私密的, 不能被外部所访问或调用, 只能被本类内部访问;

protect

面对对象封装性：

    封装是面向对象方法中的重要特性。封装是把对象的属性和行为结合成一个封装体，这个封装体内包含的属性，他们由若干个不同类型的数据组成；还包括对象的行为，他们由若干个操作组成。操作通过函数来实现，又称方法。

   封装体还具有隐藏性，封装体内某些数据和方法再封装体外是不可见的，这样就具有一定安全性。比如private 私有成员变量或者方法。

2：整理四个默认成员函数及运算符重载相关知识

类可以定义对象，类定义的对象有四个默认的成员函数：构造函数，拷贝构造函数，析构函数，赋值运算符的重载。

构造函数：

功能：在创建对象时，对对象进行初始化；我们知道，在类中我们不能直接给对象赋值，因此在c++中存在构造函数来为对象赋值。

要求：

1. 函数名与类名相同。
2. 无返回值。
3. 对象构造（对象实例化）时系统自动调用对应的构造函数。
4. 构造函数可以重载。
5. 构造函数可以在类中定义，也可以在类外定义。
6. 如果类定义中没有给出构造函数，则C++编译器自动产生一个缺省的构造函数，但只要我们定义了一个构造函数，系统就不会自动
生成缺省的构造函数。
7. 无参的构造函数和全缺省值的构造函数都认为是缺省构造函数，并且缺省的构造函数只能有一个。

eg：

class Date{

	//无参构造函数
public:
	Date()
	{
		_year = 1990;
		_month = 2;
		_day = 1;
	}

	//全缺省的构造函数
	Date(int year=1900, int month=2, int day=2)
	{
		_year = year;
		_month = month;
		_day = day;
	}

        

private:
	int _year;
	int _month;
	int _day;

};

int main()
{

        //调用无参的构造函数

        Date d;          

        //调用全缺省的构造函数
	Date d1(1990,2,2);
	return 0;
}

拷贝构造函数：

创建对象时使用同类对象来进行初始化，这时所用的构造函数称为拷贝构造函数（Copy Constructor），拷贝构造函数是特殊的构造函
数。
特征：
1. 拷贝构造函数其实是一个构造函数的重载。
2. 拷贝构造函数的参数必须使用引用传参，使用传值方式会引发无穷递归调用。
3. 若未显示定义，系统会默认缺省的拷贝构造函数。缺省的拷贝构造函数会，依次拷贝类成员进行初始化。

无穷递归问题：

如果使用传值，会创建一个临时对象，在创建这个对象时，又会调用一次拷贝构造函数，如此下去，就会一直调用，引发无穷递归。而引用传参就只是实参的临时拷贝，不创建新的对象，就不会引发无穷递归。

如以上代码所示（类体为上一个构造函数中的类代码），就是对一个拷贝构造函数的定义以及调用。

Date(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

int main()
{
	Date d1(1990,2,2);

	Date d(d1);
	return 0;
}

析构函数：

当一个对象的生命周期结束时，C++编译系统会自动调用一个成员函数，这个特殊的成员函数即析构函数（destructor）
构造函数是特殊的成员函数，其特征如下：
1. 析构函数在类名加上字符~。
2. 析构函数无参数无返回值。
3. 一个类有且只有一个析构函数。若未显示定义，系统会自动生成缺省的析构函数。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
5. 注意析构函数体内并不是删除对象，而是做一些清理工作。

~Date（）

{

//代码段

}

赋值运算符重载：

拷贝构造函数是创建的对象，使用一个已有对象来初始化这个准备创建的对象。
赋值运算符的重载是对一个已存在的对象进行拷贝赋值。

Date& operator=(const Date& d)
{
	if (this != &d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	return *this;
}

调用拷贝构造

Date d3=d1;

Date d3;

//调用赋值运算符重载

d3=d1;

隐藏的this指针：

 Date(const Date& d)//以此为例，可以看出，函数体内有_year和d._year两个变量，而在传参的时候只传了d，这里就隐藏了一个this指针指向d1的引用传参。
 {
  _year = d._year;
  _month = d._month;
  _day = d._day;
 }

在运算符重载中，必须注意this指针的使用。例如后置++；

 Date operator++(int)
 {
  Date dp(*this);
  *this = operator+(1);
  return dp;
 }

后置++返回的是+之前的值；这里就需要用到这个隐藏的this指针，this指针指向的数据改变会引起原来的数据的改变。因此我们需要拷贝构造一个临时对象对this指针来进行++运算，然后返回dp的值，这样就可以得到执行++之前的值，而且改变了this指针指向的数据