CPP语法(四)——类的声明和定义

参考链接
系列链接: CPP语法(二)——指针
系列链接: CPP语法(四)——类的声明和定义

一、 类的声明和定义

class 类名
{
    public:
    	数据成员的声明
        成员函数的声明
    private:
    	数据成员的声明
        成员函数的声明
    protected:
    	数据成员的声明
        成员函数的声明
}

自生类的对象不可以作为该类的成员，但自生类的指针或引用可以作为该类的成员。

1.1 构造函数和析构函数

如果在构造函数中new 出了空间，需要在析构函数中 进行释放。

案例：

Person.h

#include <iostream>
#include <string.h>
using namespace std;
class CPerson
{
	public:
	CPerson();
	~CPerson();//析构函数
	char* m_pMessage;
	void ShowStartMessage();
	void ShowFrameMessage();
};
CPerson::CPerson()
{
	 m_pMessage = new char[2048];
}
void CPerson::ShowStartMessage()
{	
	strcpy(m_pMessage,"Welcome to MR");
	cout << m_pMessage << endl;
}
void CPerson::ShowFrameMessage()
{	
	strcpy(m_pMessage,"**************");
	cout << m_pMessage << endl;
}
CPerson::~CPerson()
{
	delete[] m_pMessage;
}

main.cpp

#include <iostream>
using namespace std;
#include "Person.h"
void main()
{
	CPerson p;
	p.ShowFrameMessage();
	p.ShowStartMessage();
	p.ShowFrameMessage();
}

一个类中只能定义一个析构函数

析构函数不能重载

构造函数和析构函数不能使用return语句返回值，所以不需要添加返回值类型， 例如 void 等。

1.2 类成员修饰符

public 对内可见，对外可见，且对派生类可见

protected 对内可见，对外不可见，且对派生类可见

private 对内可见，对外不可见，对派生类不可见

如果在类定义中没有加任何的关键字，则默认状态下类成员都位于private区域

1.3 内联成员函数

在类成员函数前加 inline ，如果在类内部不加 inline ，默认也是认为是内联函数

class cBook
{
    inline void test();
}

//还可以  不在类内加，而在类外加
class cBook
{
    void test();
}
inline void cBook::test()
{}

1.4 类成员函数添加const

类成员函数 括号 () 后添加 const 表示该函数方法不会修改成员变量,如果该方法修改了，编译会报错，保证了程序的健壮性

#include <iostream>
using namespace std;
int a=10;
class Test{
	int a;
	public :
	int test () const{
	//a++;
	cout << a <<endl;
	cout << "hello"<<endl;
	geta();
	return a;
	}
	int geta() const{
		return 2;
	}
};

void main(){
	Test test;
	test.test();
}

1.5 静态类成员static

用static修饰的成员函数和成员变量可以直接通过类名访问

静态成员变量需要在类外进行初始化

静态成员函数 只能调用 静态成员变量。

对于静态类成员，需要注意以下几点:

(1) 静态类成员类型 可以是当下的 定义的类类型

class cBook
{
    public:
    	static cBook s_book;		//正确
    	//cBook books;		 不是静态类型不能定义自己这个类型
    	cBook * p_book;			//但是可以定义自己类型的指针
}

(2) 静态类成员可以作为成员函数的默认参数，普通类成员不行

class cBook
{
    public:
    	int price;
    	static int s_price;
    	//void test(int data=price);	错误
    	void test(int data=s_price);	//正确
}

(3) 定义静态成员函数时不能添加 const 修饰

//static void test() const;   错误

(4) 静态成员函数如果是在类外实现，不能添加static

class cBook
{
    static int price;
    static void test();
}

static void cBook::test()		//错误
{
    cout<< price <<endl;
}

void cBook::test()		//正确
{
    cout<< price <<endl;
}

1.6 嵌套类

类如果想要访问嵌套类的私有成员，需要在嵌套类中将外部类作为友元类。

如果想要定义嵌套类，需要在嵌套类前面添加外部类的作用域，如：

int main(int argc,char *argv[])
{
    CList::CNode node;
    return 0;
}

1.7 局部类

局部类就是在函数内定义的类，与正常的类没啥区别

1.8 友元

使用friend关键字让特定的函数或别的类的所有成员函数对私有数据成员进行读写，这既可以保持数据的私有性，又能够使特定的类或函数直接访问私有数据。

友元类：

#include <iostream>
using namespace std;
class CItem
{
private:
	char m_Name[128];
	void OutputName()
	{
		printf("%s\n",m_Name);
	}
public:
	friend class CList;
	void setItemName(const char * pchData)
	{
		if(pchData!=NULL)
		{
			strcpy(m_Name,pchData);
		}
	}
	CItem()
	{
		memset(m_Name,0,128);
	}

};

class CList
{
private:
	CItem m_Item;
public:
	void OutputItem();
};

void CList::OutputItem()
{
	m_Item.setItemName("bejin");
	m_Item.OutputName();
}

void main()
{
	CList clist;
	clist.OutputItem();
}

友元函数:

全局函数也能做友元函数，这里的案例是成员函数做友元函数

#include <iostream>
class CItem;								//前导声明CItem类
class CList								//定义CList类
{
private:
	CItem * m_pItem;						//定义私有数据成员m_pItem
public:
	CList();								//定义默认构造函数
	~CList();								//定义析构函数
	void OutputItem();						//定义OutputItem成员函数
};
class CItem								//定义CItem类
{
friend void CList::OutputItem();				//声明友元函数
private:
	char m_Name[128];						//定义私有数据成员
	void OutputName()						//定义私有成员函数
	{
		printf("%s\n",m_Name);				//输出数据成员信息
	}
public:
	void SetItemName(const char* pchData)		//定义共有方法
	{
		if (pchData != NULL)					//判断指针是否为空
		{
			strcpy(m_Name,pchData);		//赋值字符串
		}
	}
	CItem()								//构造函数
	{
		memset(m_Name,0,128);				//初始化数据成员m_Name
	}
};
void CList::OutputItem()						//CList类的OutputItem成员函数的实现
{
	m_pItem->SetItemName("BeiJing");			//调用CItem类的共有方法
	m_pItem->OutputName();				//在友元函数中访问CItem类的私有方法OutputName
}
CList::CList()								//CList类的默认构造函数
{
	m_pItem = new CItem();					//构造m_pItem对象
}
CList::~CList()								//CList类的析构函数
{
	delete m_pItem;						//释放m_pItem对象
	m_pItem = NULL;						//将m_pItem对象设置为空
}
int main(int argc, char* argv[])					//主函数
{
	CList list;								//定义CList对象list
	list.OutputItem();						//调用CList的OutputItem方法
	return 0;
}

1.9 命名空间

命名空间是用来消除命名冲突的最佳方式

namespace MyName
{
    int iInt1 = 10;
    int iInt2 = 20;
};

//使用命名空间的成员
MyName::iInt1 = 30;

1.9.1 嵌套命名空间

命名空间里面再来一个命名空间，用法类似。

参考链接
系列链接: CPP语法(二)——指针
系列链接: CPP语法(四)——类的声明和定义