C++ 类 class的一系列问题

c++类定义

衍生于结构体Struct，
定义了类对象包括什么(数据成员, 属性)和可以对这个对象进行什么操作(操作)。

类定义的一般格式：

class 类名{
//数据成员
《《private:》
	成员1;》
《public:
成员2;》
《protected:
成员3;》
//函数操作
《《private:》
 函数返回类型 函数名(参数){函数体};》
《public:
成员2;》
《protected:
成员3;》
}

比如下列代码：

class Box
{
   public:
      double length;   // 长度
      double breadth;  // 宽度
      double height;   // 高度
      double getVolume()
      {
         return length * breadth * height;
      }
};

需要注意：

{}之内为类体，定义数据成员和函数操作
public, private, protected 为访问限定符
1. 这三种限定符的作用域为：从该说明符出现开始到下一个说明符之前或类体结束之前
2. 如果类体开始没有限定符修饰，默认为private
3. 对于访问，只有public修饰的，可以通过对象访问，而private和protected不可通过类对象访问。还有一部分是在继承处使用

数据成员的访问

可以通过**直接成员访问运算符(.)**来访问成员。

#include <iostream>
 
using namespace std;
 
class Box
{
   public:
      double length;   // 长度
      double breadth;  // 宽度
      double height;   // 高度
      double getVolume()
      {
         return length * breadth * height;
      }
};


int main( )
{
   Box Box1;        // 声明 Box1，类型为 Box
   Box Box2;        // 声明 Box2，类型为 Box
   double volume = 0.0;     // 用于存储体积
 
   // box 1 详述
   Box1.height = 5.0; 
   Box1.length = 6.0; 
   Box1.breadth = 7.0;
 
 
   // box 1 的体积
   volume = Box1.height * Box1.length * Box1.breadth;
   cout << "Box1 的体积：" << volume <<endl;
 
   // box 1的体积
   volume = box1.getVolume()
   cout << "Box2 的体积：" << volume <<endl;
   return 0;
}

对象的创建和引用

直接定义类的实例–对象
Box box1
Box box1(参数值) 涉及到构造函数
动态创建
- 创建
  指针变量名 =new类型名(初始化方式)
- 删除
  delete 指针名

Box *pbox1=new Box();
delete pnox1;

c++ 类成员函数

1. 在类体内直接定义函数

2. 在类外定义函数

要使用范围解析运算符 ::,比如说在类内声明，类外定义函数getVolume():

class Box
{
   public:
      double length;   // 长度
      double breadth;  // 宽度
      double height;   // 高度
      double getVolume()；
     
};

double Box:: getVolume() {
         return length * breadth * height;
      }

注意：

范围解析运算符::前面加类名，表明该函数属于此类中
成员函数与内联 inline
用于消除调用函数是所造成的固定时间的消耗的方法。
在编译阶段将使用函数的定义体来替代函数调用语句c++内联函数解释

默认在类体内实现的成员函数都是内联的；如果在类体外定义函数，而仅在类体内给出函数声明，如果要实现内联，则在类外函数定义前加关键字inline


class A
{
    public:
    void Foo(int x, int y);
    
}

inline void A::Foo(int x, int y){} ;

构造函数和析构函数

构造函数

定义： 类名(参数){}
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行，并在在该对象的生命周期中只会调用一次
构造函数的名称与类的名称是完全相同的
无函数返回类型，构造函数可用于为某些成员变量设置初始值
构造函数可以重载，用不同的参数表区分
若类定义中没有给出任何构造函数，c++编译器会自动生成默认的构造函数： 类名 (){}，但是，只有程序员定义一个构造函数，系统就不会生成默认的构造函数

//演示重载构造函数
#include <iostream>
#include<cstring>
using namespace std;
 
class CGoods
{
   public:
      CGoods();
      CGoods(char [], int, float);
      CGoods(char[], float);
 
   private:
      char Name[20];
      int Amount;
      float Price;
      float Total_value;
};
// 构造函数定义

 CGoods::CGoods(){
 Name[0]='\0';
 Price=0.0;
 Amount=0;
 Total_value=0.0;
 }
 CGoods::CGoods(char name[], int amount, float price){
 strcpy(Name, name);
 Price=price;
 Amount=amount;
 Total_value=0.0;
 }
 CGoods::CGoods(char name[], float price){
 strcpy(Name, name);
 Price=price;
 Amount=0;
 Total_value=0.0;
 }

注意：

如果想使用默认的构造函数，则在定义对象时不能使用括号
比如：
CGoods Car3; Car3为CGoods类的对象，定义时调用不带参数的构造函数，
而，
CGoods Car4(); 实际上并没有调用默认的构造函数，而是定义一个函数声明。
构造函数的另一种初始化方式：

类名(参数列表): 数据成员1(参数值1), 数据成员2(参数值2)[...]

#include <iostream>
#include <stdlib.h>
using namespace std;

class CMyClass {
public:
	CMyClass(int);
	int getx() { return m_x; };
	int gety() { return m_y; };
private:
	int m_x;
	int m_y;
};

CMyClass::CMyClass(int i) : m_y(i), m_x(m_y)
{
};
/*
CMyClass::CMyClass(int i) {
	m_y = i;
	m_x = m_y;
};
*/

int main()
{
	CMyClass a(1);
	cout << a.getx() << endl << a.gety() << endl;
	system("pause");
	return 0;
}

out:

-858993460
1

而正常的在构造函数内部初始化，则不受影响，注意执行一下代码中注释的部分
2. 析构函数
在定义一个对象时，C++会自动调用构造函数创建该对象并完成初始化，而当一个对象的生命周期结束时，C++编译器会自动调用一个特殊的成员函数–析构函数，进行善后工作

析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀
无函数返回类型，并且无任何参数
一个类中有且只能有一个析构函数，可以默认
在注销对象是，系统会自动调用析构函数，通常在析构函数中完成关闭文件，释放内存等操作

#include <iostream>
#include <stdlib.h>
using namespace std;
 
class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line();   // 这是构造函数声明
      ~Line();  // 这是析构函数声明
 
   private:
      double length;
};
 
// 成员函数定义，包括构造函数
Line::Line(void)
{
    cout << "Object is being created" << endl;
}
Line::~Line(void)
{
    cout << "Object is being deleted" << endl;
}
 
void Line::setLength( double len )
{
    length = len;
}
 
double Line::getLength( void )
{
    return length;
}
// 程序的主函数
int main( )
{
   Line line;
 
   // 设置长度
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;
   system("pause");
   return 0;
}