C++基础（五）

0x01类

基本操作

#include <iostream>
using namespace std;
	 
class  BOX
{
public:
	double changdu;
	double kuandu;
	double gaodu;
};

int main()
{
	BOX b1;
	BOX b2;
	double tiji = 0.0;
	b1.changdu = 1;
	b1.gaodu = 1;
	b1.kuandu = 1;
	tiji = b1.changdu * b1.gaodu * b1.kuandu;

	cout << "tiji" << tiji << endl;
	return 0;

}

把计算体积的函数也放进类中并调用

#include <iostream>
using namespace std;
	 
class  BOX
{
public:
	double changdu;
	double kuandu;
	double gaodu;

	double gettiji(void)
	{
		return changdu * kuandu * gaodu;
	}
};

int main()
{
	BOX b1;  //创见美一个对象
	b1.changdu = 1;
	b1.gaodu = 1;
	b1.kuandu = 1;
	double b1detiji = 0;

	b1detiji = b1.gettiji();  //调用类的函数
	cout << "tiji" << b1detiji << endl;
	return 0;
}

多个类调用

#include <iostream>
using namespace std;

class  BOX
{
public:
	double changdu;
	double kuandu;
	double gaodu;

	double gettiji(void)
	{
		return changdu * kuandu * gaodu;
	}
};

class YUANZHUTI
{
public:
	double banjin;
	double gao;
	double pai = 3.14159;

	double gettiji(void)
	{
		return  banjin * gao * pai;
	}

};

int main()
{
	BOX b1;
	double b1detiji = 0;
	b1.changdu = 1;
	b1.gaodu = 1;
	b1.kuandu = 1;
	b1detiji = b1.gettiji();

	
	YUANZHUTI y1;
	double y1detiji = 0;
	y1.gao = 1;
	y1.banjin = 2;
	y1.pai = 1;
	y1detiji = y1.gettiji();
	cout << "tiji" << b1detiji << endl;
	cout << "tiji" << y1detiji << endl;
	return 0;
}

访问修饰符

数据隐藏是面向对象编程的一个重要特点，它防止函数直接访问类类型的内部成员。类成员的访问限制是通过在类主体内部对各个区域标记 public、private、protected 来指定的。关键字 public、private、protected 称为访问说明符。

一个类可以有多个 public、protected 或 private 标记区域。每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的。成员和类的默认访问修饰符是 private。
    
class Base {
 
   public:
 
  // public members go here
 
   protected:
 
  // protected members go here
 
   private:
 
  // private members go here
 
};

public

公有成员在程序中类的外部是可访问的。您可以不使用任何成员函数来设置和获取公有变量的值：

#include <iostream>
using namespace std;

class Line
{
public:
	double changdu;
	void setchangdu(double cd);
	double getchangdu(void);
};
double Line::getchangdu(void)//成员函数定义
{
	return changdu;
}
void Line::setchangdu(double cd)
{
	changdu = cd;
}


int main()
{
	Line nowline;

	nowline.setchangdu(11.1);  //通过函数设定长度
	cout << "长度：" << nowline.getchangdu() << endl;

	nowline.changdu = 11.1;//不使用函数设定长度 changdu是公有的
	cout << "长度：" << nowline.changdu << endl;
	return 0;
}

private

私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。

默认情况下，类的所有成员都是私有的。例如在下面的类中，width 是一个私有成员，这意味着，如果您没有使用任何访问修饰符，类的成员将被假定为私有成员：
    
#include <iostream>
using namespace std;

class Box
{
public:
    double length;
    void setWidth(double wid);
    double getWidth(void);

private:
    double width;
};

// 成员函数定义
double Box::getWidth(void)
{
    return width;
}

void Box::setWidth(double wid)
{
    width = wid;
}

// 程序的主函数
int main()
{
    Box box;

    // 不使用成员函数设置长度
    box.length = 10.0; // OK: 因为 length 是公有的
    cout << "Length of box : " << box.length << endl;

    // 不使用成员函数设置宽度
    // box.width = 10.0; // Error: 因为 width 是私有的
    box.setWidth(10.0);  // 使用成员函数设置宽度
    cout << "Width of box : " << box.getWidth() << endl;

    return 0;
}

protected

保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的
在这里 width 成员可被派生类 smallBox 的任何成员函数访问
    
#include <iostream>
using namespace std;

class Box
{
protected:
    double width;
};

class SmallBox :Box // SmallBox 是派生类
{
public:
    void setSmallWidth(double wid);
    double getSmallWidth(void);
};

// 子类的成员函数
double SmallBox::getSmallWidth(void)
{
    return width;
}

void SmallBox::setSmallWidth(double wid)
{
    width = wid;
}

// 程序的主函数
int main()
{
    SmallBox box;

    // 使用成员函数设置宽度
    box.setSmallWidth(5.0);
    cout << "Width of box : " << box.getSmallWidth() << endl;

    return 0;
}

1x02继承

面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行时间的效果。

当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。

继承代表了 is a 关系。例如，哺乳动物是动物，狗是哺乳动物，因此，狗是动物，等等。

基类 & 派生类

一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：

class derived-class: access-specifier base-class

其中，访问修饰符 access-specifier 是 public、protected 或 private 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private

#include <iostream>
using namespace std;

class shape
{
public:
	void setkuandu(int k)
	{
		kd = k;
	}
	void setgaodu(int h)
	{
		gd = h;
	}
protected:
	int kd;
	int gd;
};
//派生类
class sanjiao: public shape {
public:
	int getmianji()
	{
		return 0.5 * kd * gd;
	}
};
class juxin : public shape {
public:
	int getmianji()
	{
		return kd * gd;
	}
	};
int main(void) {
	sanjiao mysanjiao;
	mysanjiao.setgaodu(1);
	mysanjiao.setkuandu(2);
	
	juxin myjuxin;
	myjuxin.setgaodu(1);
	myjuxin.setkuandu(1);

	cout << "面积：" << mysanjiao.getmianji() << endl;
	cout << "面积：" << myjuxin.getmianji() << endl;
	return 0;
}

访问控制和继承

派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。

一个派生类继承了所有的基类方法，但下列情况除外：
基类的构造函数、析构函数和拷贝构造函数。
基类的重载运算符。
基类的友元函数。

相关权限如下划分

访问	public	protected	private
同一个类	yes	yes	yes
派生类	yes	yes	no
外部的类	yes	no	no

继承类型

当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。

我们几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：

公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。
多继承

多继承

多继承即一个子类可以有多个父类，它继承了多个父类的特性。

C++ 类可以从多个类继承成员，语法如下：
其中，访问修饰符 access 是 public、protected 或 private 其中的一个，用来修饰每个基类，各个基类之间用逗号分隔

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};


#include <iostream>

using namespace std;

// 基类 Shape
class Shape
{
public:
    void setWidth(int w)
    {
        width = w;
    }
    void setHeight(int h)
    {
        height = h;
    }
protected:
    int width;
    int height;
};

// 基类 PaintCost
class PaintCost
{
public:
    int getCost(int area)
    {
        return area * 70;
    }
};

// 派生类
class Rectangle : public Shape, public PaintCost
{
public:
    int getArea()
    {
        return (width * height);
    }
};

int main(void)
{
    Rectangle Rect;
    int area;

    Rect.setWidth(5);
    Rect.setHeight(7);

    area = Rect.getArea();

    // 输出对象的面积
    cout << "Total area: " << Rect.getArea() << endl;

    // 输出总花费
    cout << "Total paint cost: $" << Rect.getCost(area) << endl;

    return 0;
}