C++学习

#include <iostream>
#include <windows.h>

#define FULL_GAS 85

class Car
{
	public:
		std:string color;
		std:string engine;
		unsigned int gas_tank;
		unsigned int wheel;
		
		void setColor(std::string col);
		void setEngine(std::string eng);
		void setWheel(unsigned int whe);
		void fillTank(int liter);
		int running(void);
		void warning (void);
};

void Car::setColor(std::string col)
{
	color=col;
}

void Car::setWheel(unsigned int whe)
{
	engine=eng;
}

void Car::setWheel(unsigned int whe)
{
	wheel=whe;
}

void Car::fillTank(int liter)
{
	gas_tank+=liter;
}

int Car::running (void)
{
	std::cout<<"我正在以120的时速往前移动···越过那高山越过那河···\n";
	gas_tank--;
	std::cout<<"当前还剩"<<100*gas_tank/FULL_GAS<<"%"<<"油量！\n";
    
    return gas_tank;
}

void Car::warning(void)
{
	std::cout<<"WARNING!!"<<"还剩"<<100*gas_tank/FULL_GAS<<"%"<<"油量！\n";
}


int main()
{
	char i;
	Car mycar;
	
	mycar.setColor("WHITE");
	mycar.setEngine("V8");
	mycar.setWheel(4);
	
	mycar.gas_tank=FULL_GAS;
	
	while(mycar.running())
	{
		if(mycar.running()<10)
		{
			mycar.running();
			std::cout<<"请问是否需要加满油再行驶？(Y/N)\N";
			std::cin>>i;
			if('Y'==i||'Y'==i)
			{
				mycar.fillTank(FULL_GAS);
			}
		}
	}
	return 0;
}

 

首先是闭门造车小程序

 继承机制中的构造器和析构器
●正如此前所讲解的. C ++支持程序员目己写出将创建或销毀一个对象时目动调用的方法，也就是构浩器和析构器。
●在没有继承机制的情凡下，我们很容易理解这些方法
在创建或销毁一个对汞69汁候被调用。但是一으便用用了继承机制，构浩器和析构器就变得有点度杂了。

●比如基类有个构浩器，如 Animal ()，它将在创迭 Piq 类型的对象时最先被调用．如果 Pig 类也有一个构浩器，它将排在第二个被调用。为基类必项在子类之前初始化原则！

●然后我门继续计论：如果构浩器带着输入叁数，
事情变得稍微复杂了。
 

class Animal 
{ 
    public
     Animal ( std : istring theName ); 
     std :: string name ;
}
 class Pig : public Animal 
{
     public :
     Pig ( std : istring theName );
}

应该这样定义

Animal :: Animal ( std :: string theName )
{
     name = theName ;
}
Pig :: Pig ( std : string theName ): Animal ( theName )
{
}

●在销毀某个对象时，基类的析构器也将被自动调用，但这些事情编译器会自动彗你处理
●因为析构器不熏尊输入叁数，所以根本用不着使用： SuperClassMethod ( arguments ）语法！
●与构浩器的情况相反，基类的析构器将在子类的最后一条语句执行完毕后才被调用。

# include < iostraem >
# include < string >

class BaseClass 
{
    public ：
     Baseclass （）;
    ~ BaseClass （）;
     void doSomething （）;
}

 class SubClass: public BaseClass
｛
     SubClass();
    ~ SubClass ();
};
     BaseClasS :: BaseClass ()
     std :: cout <<"进入基类构造器。。。
     std :: cout <<"我在基类构造器里边干了某些事。。。。\n\n ";
}

     BaseClasS ::~ BaseCLass()
{
      std :: cout <<"进入基类析构器．......\ n ";
      std :: cout <<"我在基类析构器里边也干了某些事。。。。\ n \ n ";
}
     Void BaseClass :: doSomething ()
{
     std :: Cout <<"我千了某些事。。。。\ n \ n ";
}
     SubClass :: SubClass ()
{
 std :: Cout <<"进入子类构造器．.●..\ n ";
 std :: cout <<"我在子类构造器里边还千了某些事，,\ n \ n ";
}
 SubClass :~ SubClass ()
{
 std :: cout <<"进入基类析构器...\ n ";
}
 return 0;
}

关于构诰器的设计要越简明越好好!我们应该只用它来初始化名种有关的属性。
●作为一个基本原则,在设计、定义和体用一个类的时候,应该让它的每个组成部分3分简单到不能再
简单!
●最后一点别忘了,析构器的基本用用途是对前面所做的事情进行结理。尤其是在萸用了动动态内存的程序里,析构器将至关重要!

访问控制
在此前的冽子里，我们无论是 Animal , Pig 和 Turtle 类的所有成员都是用 public ：语句声明所谓访问控制，就是 C ++提供了一种用来保护类里的方法和属性的手段（保护是对谁都可以调用某个方法和访问某个属性加上一个限制。）如果某个对象试图调用用一个它无权访6l的函数，编译器将报错。

 利用访问级别来保护类里的方法和属性很简单，只要在类里的某个地方写出一个访问级别并在其后加上一个冒号，从那个地方开始往后的所有方法和属性都将受到相应的保护，直到遇到下一个访问级别或者到达这个类的末尾为止！

使用 private 的好处是，今后可只修改某个类的内部实现，而不必重新修改整个程序。这是因为其他代码根本就访问不到 private 保护的内容，所以不怕"牵一发而动全身"的惨剧发生！