复习笔记（三）——C++类和对象

类和对象在内存中的关系

一个类的多个对象各自拥有类的数据成员的一个副本。

类的成员函数则被其所有对象共享。

一个类的不同对象响应相同的消息时，调用的是同一个函数。

下面举个例子：

class Student{
private:
	Char name[21];
	Char no[4];
	Int age;
	Int score[5];
public:
	PrintStudent();
	Student();
	~ Student();
	GetTotal();
	GetAVG();
};

this指针

每个对象都有一个指向自身的this指针 （对象的内存地址）

对象调用成员函数时会将自己的this指针传递给成员函数（隐含参数） PrintStudent(this);

成员函数访问对象的所有数据成员都是通过this指针访问

this指针的另外一个作用——访问对象自身（*this）

实例：

#include <iostream.h>
class Test {
public:
	Test(int n = 0);
   	Test & setData(int n);
	void print();
private:
	int data;
};
Test::Test(int n){
	this->data = n;		//data=n;
}
Test & Test::setData(int n) {
   data = n;		//this->data=n;
   return *this;
}
void Test::print() {
   cout<<"data = "<<data<<"!"<<endl;
}
void main() {
   Test obj1;
   cout<<"obj1: ";
   obj1.setData(100).print();
}

执行结果：
obj1: data = 100!

类的静态成员

类的数据成员和成员函数都可以声明为static。

静态成员解决数据共享的问题。
-实现共享：在类外设置全局变量，但是，全局变量都有局限性,破坏类的完整性 。

类的静态数据成员可以在类的范围内存储数据，这种数据独立于类类型中的任何对象，但可以由这些对象访问。

静态成员函数有一种独立于对象的计算能力。

类的非静态成员函数可以访问类的静态成员

静态数据成员

类中的普通成员对每个对象都有一个单独的副本实例。
类中的静态数据成员是该类所有对象所共同拥有的,只有一个实例，它不因对象的建立而产生，也不因对象的失效而删除，它是类定义的一部分，它属于整个类，即属于所有对象 。

定义： static 数据类型 数据成员名称;

初始化：静态数据成员不能由构造函数初始化，只能在类定义外使用::范围解析来完成
[static] 数据类型 类名::数据成员名称=初始值;

访问：类名::静态数据成员

示例：

#include <iostream.h>

class CFile
{
private:
	char *m_fileName;
public:
	static bool saveState;
	File();
	File(char *fileName);
};
//定义初始化静态成员
bool CFile::saveState=true;

int main()
{
	if(CFile::saveState==true)
	{
		//文件已保存
	}
	else
	{
		//文件未保存
	}
	return 0;
}

静态成员函数

静态成员函数是操作静态数据成员的函数。

定义: static 返回类型 函数名(参数列表)

访问：类名::静态成员函数

**注意：
①静态成员函数不能声明为const因为静态成员函数与类的对象无关，它没有this指针，所以不能用const关键字。
②静态成员函数不能访问类的非静态成员变量。
③静态成员函数不能调用非静态成员函数。
④静态成员函数的优点在于:即使不存在类的对象，它们也存在，并且可以调用。
⑤非静态成员函数可以访问静态数据成员，也可以调用静态成员函数。

实例：

#include <iostream.h>

class MessageBox
{
public:
	enum MessageBoxButtons{OK=0,YesNo=1,YesNoCancel=2};
	enum DialogResult{Yes=0,No=1,Cancel=3};
	static void Show(char *message);
	static DialogResult Show(char * message,MessageBoxButtons buttons);
};
void MessageBox::Show(char *message)
{
	cout<<message<<endl;
}
MessageBox::DialogResult MessageBox::Show(char *message, MessageBox::MessageBoxButtons buttons)
{
	cout<<message<<endl;
	switch(buttons)
	{
	case OK:
		cout<<"OK"<<endl;
		break;
	case YesNo:
		cout<<"YesNo"<<endl;
		break;
	case YesNoCancel:
		cout<<"YesNoCancel"<<endl;
		break;
	}
	return Yes;
}
void main()
{
	MessageBox::Show("Sure Exit(y/n)?",MessageBox::YesNo);
}

执行结果：
Sure Exit(y/n)?
YesNo

指针与对象

对象的指针:和一般的指针变量的声明和设定方式相同
Book a_book; //声明一个Book对象。
Book* book_ptr; //声明一个Book对象指针
book_ptr = &a_book;//把已有a_book对象赋值给对象指针

动态分配对象内存，利用new运算符声明对象并以动态分配内存的方式建立
类名* 指针名=new 类名(参数表);

取成员：
对象指针名-> 成员名
Delete 指针名;

对象参数的传递

函数传递参数的方式(传值/地址/引用)。

如果函数需要存储或更改对象成员变量中的数据，则必须通过引用将对象传递给它。

可以使用const修饰符禁止改变原始值

示例：

void call_by_ref(Book&);  //通过引用接受对象
void ring_by_ref(Book);   //按值传递
int main()
{
	Book a_book;
	call_by_ref(a_book);
	ring_by_ref(a_book)
	return 0;
}
void call_by_ref(Book& abook)
{······}

const 对象

如果把一个对象指定为const，就是告诉编译器不要修改它。

const对象的定义：const 类名 对象名(参数表);

const对象不能调用非const成员函数

示例：

class Sample
{
public:
    void GetValue() const {} // 常量成员函数
    void func(){}
    int m_value;
};

void Sample::GetValue() const // 常量成员函数
{
    value = 0; // 出错
    func(); // 出错
}

int main()
{
    const Sample obj;
    obj.value = 100; // 出错，常量对象不可以被修改
    obj.func();    // 出错,常量对象上面不能执行 非 常量成员函数
    obj.GetValue;   // OK,常量对象上可以执行常量成员函数
    
    return 0;
}

const 数据成员

和声明普通const变量的方法相同。

const数据成员的初始化：在构造函数使用初始化列表。

示例：

class ClassMember
{
private:
	Student stu[100];
	int m_stuNum;
public:
	const int MAXCOUNT1;
	const int MAXCOUNT2;
	int GetStuNum() const;
};
ClassMember::ClassMember():MAXCOUNT1(10), MAXCOUNT2(20){
	this->m_Count=0;
}

const 成员函数

const成员函数不会修改调用它的对象。

const成员函数只能访问数据成员的值，而不能修改它

声明方式：在声明和定义的时候在函数头部的结尾加上 const 关键字

示例：

class Student
{
public:
	int GetChinese() const;
private:
	int m_score[5];
};
int Student::GetChinese() const
{
	return m_score[0];	//相当于只读
}

存取权限的补充 mutable

用于定义更改频繁的数据成员. 数据成员即使在const对象或在const成员函数中都可以被修改

实例：

#include <iostream>
#include <string>
using namespace std;

class CRect
{
public:
	int getwid() const;
public:
	mutable int m_wid;
};
int CRect::getwid() const
{
	 m_wid = 8;
	return m_wid;
}
int main()
{
	CRect re;
	re.getwid();
	printf("m_wid = %d\n",re.m_wid);
	return 0;
}

执行结果：
8