通过练习来熟练C++类的使用

我们设计一个矩形类

class Rectangle
{
private:
	int left, top, right, bottom;
public:
	Rectangle()
	{}
	Rectangle(int e = 0, int t = 0, int r = 0, int b = 0) :left(e), top(t), right(r), bottom(b)
	//仅能使用初始化列表对构造函数进行初始化
	{}
	
	void SetLeft(int e) {left = e;}
	void SetTop(int  t) {top = t;}
	void SetRight(int r) {right = r;}
	void SetBottom(int b) {bottom = b;}
	
	int GetLeft() const {return left;} //我们不对对象成员进行改变的时候，尽可能定义为常方法
	int GetTop() const {return top;}
	int GetRight() const {return right;}
	int GetBottom() const {return bottom;}
	
	void Show() const
	{
		cout << "left-top point is (" << left << "," << top << ")" << endl;
		cout << "right-bottom point is (" << right << "," << bottom << ")" << endl;
	}


}

1.

这里有一个问题：我们的构造函数可以使用列表方式进行初始化，而其他成员函数不可以使用列表，这是因为当我们创建对象调动构造函数，我们在构造函数中构建我们的属性，而若用其他函数使用列表会造成二次构建，这是不允许的

我们看下面一个例子：

当我们调用SetValue的时候，obj在t1中已经构造完成，是不允许其他的成员函数对t1内部对象进行进行二次构建的，所以初始化列表只能存活于构造函数，

2.

对于不需要将对象成员进行改变的时候，尽可能定义为常方法，这样使得我们可以在使用常引用，仍然可以通过这个常方法去调用；也就是既可以适用于普通对象，也可以使用常对象进行调用，使用更加广泛

const Revtangle &r = r2;
r.GetLeft();

实现双向函数

class Object
{
private:
	int value;
public:
	Object(int x = 0) :value(x) {}
	~Object() {}
	void SetValue(int x) { value = x; }
	int GetValue() { return value; }
	// 使用一个函数实现 SetValue 和 GetValue() 函数的功能
};

int main()
{
	Object obj(10);
	int x = obj.GetValue();
	obj.SetValue(100);
	x = obj.GetValue();
}

我们希望设计一个函数来完成上面两个成员函数的功能

class Object
{
private:
	int value;
public:
	Object(int x = 0) :value(x) {}
	~Object() {}
	
	int& Value() { return value; }
	const int& Value()const { return value; }
};

void fun(const Object& obj)
{
	const int x = obj.Value();
}
int main()
{
	Object obj(10);
	obj.Value() = 20;
	int x = obj.Value();

	fun(obj);
}

这里我们即给出int& Value() { return value; } 又给出 const int& Value()const { return value; }，这样我们的普通对象既可以调用普通方法又可以调用常方法，我们的常对象只能调用常方法

并且在这个地方属于函数的重载

	int& Value() { return value; }
	//int& Value(Object* const this)
	const int& Value()const { return value; }
	//const int& Value(const Object* const this)

C++对函数重载的依据，首先函数名相同，参数列表不同；这里我们的this指针类型并不相同，且返回类型不能作为函数重载的依据

int main()
{
	Object obj(10);
	obj.Value(); //Value(&obj);
	const Object objc(20);
	objc.Value();//Value(&objc);
}

我们在这里面对于obj,调用第一个Value函数，而objc去调用第二个Value函数；并且如果我们将第一个Value函数去掉，我们程序仍然可以编译通过，若将第二个Value函数去掉，这样函数就无法编译通过，objc就会产生错误

实现一个栈

#define SEQ_INIT_SIZE 10
#define SEQ_INC_SIZE 2
class SeqStack
{
private:
	int* base;
	int* pos;
	int maxsize;
public:
	SeqStack(int sz = SEQ_INIT_SIZE) :maxsize(sz > SEQ_INIT_SIZE ? sz : SEQ_INIT_SIZE)
	{
		base = pos = (int*)malloc(sizeof(int) * maxsize);
		if (NULL == base) exit(1);
	}
	//实现函数有：
	~SeqStack() // 析构函数
	{
		free (base);
		base = NULL;
	}
	int Get_Size() const // 返回数据的个数
	{
		return pos - base;
	}  
	int Get_Capacity()const  //返回数据个数
	{
		return maxsize;
	}
	bool Is_Empty()const //判空
	{ 
		return Get_Size == 0;
	}
	bool Is_Full()const //判满
	{
		return maxsize == Get_Size();
	}
	bool Push(int val)  // 入栈
	{
		if (Is_Full())
		{
			return false;
		}
		*pos = val;
		pos++;
		return true;
	}
	bool Pop()       //出栈
	{
		if (Is_Empty())
		{
			return false;
		}
		pos--;
	}
	int Top()      // 取栈顶数据 ，但不出栈     
	{
		if (Is_Empty())
		{
			return false;
		}
		return *pos;
	}
};