C++ 面向对象程序设计

1、什么是面向对象程序语言

2、面向对象语言的特征

抽象、封装、继承、多态

3、什么是类、对象和成员

人类就是一个类，他包含很对对象，比如张三、李四等都是人类的一个对象，这些对象有共同的功能和数据，比如身高，体重等，或者是可以喝水，吃饭等等，这些东西可以看做人类共有的方法或者函数。

类是由若干变量和相关函数组成，而对象可以拥有这些变量和函数。

4、声明一个类

# include<iostream>
using namespace std;
class Human
{
public:
	void GetStature;
	void GetWeight;
private:
	int stature;
	int weight;
	//private：表示他后面的成员都是私有的，不能被对象直接访问，必须通过公有的成员函数才能访问
};
void mian()
{

}

5、命名习惯

# include<iostream>
using namespace std;
class Human
//Human全部大写或者全部小写都可以。
{
public:
	void GetStature();
	void GetWeight();
	//以上叫骆驼命名法，首字母大写；还有一个叫get_stature,下划线命名法。
private:
	int stature;
	int weight;
};
void main()
{

}

6、定义一个对象

# include<iostream>
using namespace std;
class Human
{
public:
	void GetStature(){cout<<stature<<endl;}
	void GetWeight();//只是声明了一个函数
	void SetStature(int x){stature=x;}
	void SetWeight(int);//声明也要有参数
private:
	int stature;
	int weight;
};
void Human::GetWeight()
{
	cout<<weight<<endl;
}
void Human::SetWeight(int x)
{
    weight=x;
}
void main()
{
	Human Mike;
	Mike.SetStature(160);
    Mike.GetStature();
    Mike.SetWeight(80);
    Mike.GetWeight();
	//Mike.stature=4;是错误的，私有成员不能直接访问。
	//以上是定义一个对象的两种方式
}

运行结果：

7、定义类或者对象容易犯的错误

类是个抽象的名词，不是具体的个体，我们不能对其进行复制操作；比如，我们不能int=9;一样

# include <iostream>
using namespace std;
class Human
{
public:
	int weight;
	void walk(){cout<<"走路"<<endl;}
};
int main()
{
	//Human.weight=8;我们不能给一个类的成员赋值，只能给一个对象的成员赋值 才行。
	Human Tom;
	Tom.weight=8;//这样才是正确的
	Tom.walk();
	//Tom.sleep();这样是错误的，对象不能调用类中没有的成员.
}

8、公有和私有

# include <iostream>
using namespace std;
class Human
{
public:
	int weight;
};
int main()
{
	Human Tom;
	Tom.weight=80;
	cout<<Tom.weight<<endl;
	Human Mike;
	Mike.weight=90;
	cout<<Mike.weight<<endl;
	//每个对象都可以访问或者修改共有成员的变量，去掉public就会报错。因为类的成员默认为私有成员。私有成员不能被对象直接访问，只能通过在类中设定的接口函数来访问。
}

# include <iostream>
using namespace std;
class Human
{
public:
	int set(int x){weight=x;return weight;}
private:
	int weight;
};
int main()
{
	Human Tom;
	cout<<"Tom的体重为："<<Tom.set(180)<<endl;
	Human Mike;
	cout<<"Mike的体重为："<<Mike.set(160)<<endl;
}

运行结果：

以上两个程序都能输出两个人的体重，为什么要用接口函数呢？

# include <iostream>
using namespace std;
class Human
{
public:
	void set(int x)
	{
		if(x>0&&x<100)
		{
		weight=x;
		}
		else 
		{
			cout<<"请输入一个大于零小于一百的数字，否则默认返回零！"<<endl;
			weight=0;
		}
	}
	int show(){return weight;}
private:
	int weight;
};
int main()
{
	Human Tom;
	Tom.set(190);
	cout<<"Tom的体重为："<<Tom.show()<<endl;
	Human Mike;
	Mike.set(80);
	cout<<"Mike的体重为："<<Mike.show()<<endl;
}

运行结果：

9、成员函数的定义和声明

# include <iostream>
using namespace std;
class Human
{
public:
	void set(int);
	int show();
private:
	int weight;
};
void Human::set(int x)
	{
		if(x>0&&x<100)
		{
		weight=x;
		}
		else 
		{
			cout<<"请输入一个大于零小于一百的数字，否则默认返回零！"<<endl;
			weight=0;
		}
	}
int Human::show()
{
	return weight;
}
int main()
{
	Human Tom;
	Tom.set(190);
	cout<<"Tom的体重为："<<Tom.show()<<endl;
	Human Mike;
	Mike.set(80);
	cout<<"Mike的体重为："<<Mike.show()<<endl;
}

运行结果：

本例只是上例的声明和定义分开来写的！

10、内联函数

为什么声明和定义要分开来写？

我们可以用inline来解决，使用inline声明一个函数时，

# include<iostream>
using namespace std;
inline int set();
//声明了一个内联函数
int set(){return 18;}
int main()
{
	cout<<set()<<endl;
	//这就相当于把return 18拷贝到set()部分  就相当于直接输出 cout<<return 18<<endl;是一样的。
	return 0;
}

运行结果：

# include<iostream>
using namespace std;
inline int func(int);
int func(int x){return x;}
//内联函数体的代码大的时候不建议这么做，本例只有一条语句，使用内联函数是相当划算的
int main()
{
	int x;
	cout<<"请输入一个数字："<<endl;
	cin>>x;
	cout<<endl;
	cout<<"输入的数字为："<<func(x)<<endl;
	//由于定义的是内敛函数，程序运行时，会自动把定义部分的return x放到func(x)来执行，节省了一次跳转
	//正常情况下，遇到func(x)要跳转到程序的定义部分，然后执行函数，最后在跳转回来。
	return 0;
}

运行结果：

成员函数的内联函数

# include<iostream>
using namespace std;
class A
{
public:
    inline void func(int);
	inline int get();
private:
	int x;

};
void A::func(int a)
{
	x=a;
}
int A::get()
{
	return x;
}
int main()
{
	A a;
	int x;
	cout<<"请输入一个数字："<<endl;
	cin>>x;
	a.func(x);
	cout<<endl;
	cout<<"输入的数字为："<<a.get()<<endl;
	return 0;
}

运行结果：

11、头文件与源文件

我们一般把类的声明和定义放到一个文件里，该文件的后缀是.h

将程序的执行部分放到一个另一个文件里，该文件的后缀为.cpp

这样你就可以在.cpp文件的顶端写下如下代码，使.h的文件与.cpp的文件相关联：

# include"*.h"(中间的*号是.h文件的名字)

一个.h文件可以同时被多.cpp的文件调用

human.h

# include<iostream>
using namespace std;
class A
{
public:
 void func(int i,int j){x=i;y=j;}
 void print(){cout<<"两个数相乘的结果为："<<x*y<<endl;}
private:
 int x;
 int y;
};

human.cpp

# include "human.h"
int main()
{
 A a;
 a.func(3,4);
 a.print();
 return 0;
}

12、const成员函数

如果你不想让某个成员函数修改成员变量的值，那么不妨将这个成员函数声明为const

# include<iostream>
using namespace std;
class A
{
public:
 void func(int i,int j){x=i;y=j;}//本来就是要改变私有成员，不能加const
 void print()const{cout<<"两个数相乘的结果为："<<x*y<<endl;}
//由于本成员函数不会去修改私有成员的值，因此我们不妨将给函数写成const成员函数,这样就无法修改私有成员变量，修改会报错
 //编程时一定多使用const，对不应改变对象的成员函数都应声明为const 这样改变的话系统就会报错
private:
 int x;
 int y;
};
int main()
{
 A a;
 a.func(3,4);
 a.print();
 return 0;
}

运行结果：

13、构造函数

构造函数是一种特殊的成员函数,它主要用于为对象分配存储空间,对数据成员进行初始化.构造函数具有一些特殊的性质:

(1)构造函数的名字必须与类同名;

(2)构造函数没有返回类型，它可以带参数，也可以不带参数。

(3)声明类对象时,系统自动调用构造函数,构造函数不能被显式调用;

(4)构造函数可以重载,从而提供初始化类对象的不同方法;

(5)若在声明时未定义构造函数,系统会自动生成默认的构造函数,此时构造函数的函数体为空.

# include<iostream>
using namespace std;
class rectangel
{
public:
 rectangel(int i,int j){length=i;width=j;}
 int area()const{return length*width;}
private:
 int length;
 int width;
};
int main()
{
    rectangel a(4,5);
    cout<<"长方形的面积为："<<a.area()<<endl;
}

运行结果：

# include<iostream>
using namespace std;
class rectangel
{
public:
 //rectangel(int i,int j){length=i;width=j;}
//本例这样写，编译是没有错误的。假如我们不提供一个构造函数，体统会自动给我们分配一个默认的构造函数，该函数什么也没有，也不执行任何操作，它的作用就是构造了一个对象。rectangel(){}  可写可不写。当我们创建了一个构造函数，默认构造函数就会被消除。
 int area()const{return length*width;}
private:
 int length;
 int width;
};
int main()
{
 rectangel a;
 //rectangel a(4,5);
    //cout<<"长方形的面积为："<<a.area()<<endl;
}

我们可以同时创建一个带参数和不带参数的构造函数，系统会自动知道到各自的调用

# include<iostream>
using namespace std;
class rectangel
{
public:
 rectangel(int i,int j){length=i;width=j;}
 rectangel(){cout<<"构造函数在运行..."<<endl;}
 int area()const{return length*width;}
private:
 int length;
 int width;
};
int main()
{
 rectangel a(4,5);
    cout<<"长方形的面积为："<<a.area()<<endl;
 rectangel b;
}

运行结果：

14、析构函数

析构函数和构造函数相反，构造函数用于构造一个对象，析构函数则是用于对象被销毁后清除他所占的内存空间，比如说可以清除由构造函数创建的内存。

析构函数和构造函数一样不能有返回值，也不能有参数，一个类只能有一个析构函数

# include<iostream>
using namespace std;
class A
{
public:
 A(){cout<<"构造函数运行中\n";}
 ~A(){cout<<"析构函数运行中\n";}
 //viod ~A(){}   是错误的
 //~A(int i){}   是错误的
};
int main()
{
 A a;
 return 0;
}

运行结果：

分析：右大括号表示程序结束，对象a的生命周期也就结束了，这时系统会调用该类的析构函数，释放掉该对象所占的内存

先声明后定义

# include<iostream>
using namespace std;
class A
{
public:
 A();
 ~A();
};
A::A(){cout<<"构造函数运行中\n";}
A::~A(){cout<<"析构函数运行中\n";}
int main()
{
 A a;
 return 0;
}

运行结果：

析构对象数组

# include<iostream>
using namespace std;
class A
{
public:
 A();
 ~A();
};
A::A(){cout<<"构造函数运行中\n";}
A::~A(){cout<<"析构函数运行中\n";}
int main()
{
 A a[2];
//定义了两个对象a[0]和a[1];
 return 0;
}

运行结果：

注释：程序执行了两次构造函数，程序结束时，又执行了两次析构函数释放掉两个对象所占的内存。