把具有相同属性和相同操作的一些对象抽象为一个类，这些对象都是这个类的实例。封装是一种信息隐藏技术，封装可以将一部分属性和操作隐藏起来，不让使用者使用，另一部分作为类的外部接口。继承是新建的类从已有的类那里得到已有的特征。继承有效的实现了软件的重用，增强了系统的可扩充性。多态是面向对象程序设计的一个重要机制。类有比基本类型更强大的功能，类是数据和函数的封装体；
成员函数对类中数据成员的操作，它描述了类的行为，由于对象的封装性类的成员函数是对类的私有数据成员进行操作的唯一途径。
为了程序的可靠性，一般隐藏数据成员。
#include<iostream.h>
void meet(double x,double y)
{
cout<<"2数的和是";
cout<<x+y<<endl;
}
void meet(char x)
{
cout<<"字符串是： ";
cout<<x<<endl;
}
int main()
{
meet(7.2,5.3);
meet(‘a‘);
return 0;
}
一个类可以没有私有成员，但是不可以没有公有成员。因此设计一个类的时候，一定要有公有成员，它是类的外部接口，为了实现信息隐蔽，就一定要有私有成员。
#include<iostream>
using namespace std;
class Date{
private:
int year;
int month;
int day;
public:
void Set(int a,int b,int c)
{
year=a;
month=b;
day=c;
}
void Display()
{
cout<<"现在时间是"<<year<<"年"<<month<<"月"<<day<<"日"<<endl;
}
};
class shijian{
private:
int hour,minute,second;
public:
void Set(int a,int b,int c)
{
hour=a;
minute=b;
second=c;
}
void Display()
{
cout<<"现在时间是"<<hour<<"时"<<minute<<"分"<<second<<"秒"<<endl;
}
};
int main() // 主函数
{
shijian a; // 类的对象可以调用类的公有函数
a.Set(2015,1,17);
a.Display();
return 0;
}
成员函数的实现可以这样做，在类外可以加上作用域：
#include<iostream>
using namespace std;
class Date{
private:
int year;
int month;
int day;
public:
void Set(int a,int b,int c); //成员函数
void Display(); //成员函数
};
class shijian{
private:
int hour,minute,second;
public:
void Set(int a,int b,int c)
{
hour=a;
minute=b;
second=c;
}
void Display()
{
cout<<"现在时间是"<<hour<<"时"<<minute<<"分"<<second<<"秒"<<endl;
}
};
void Date::Set(int a,int b,int c)
{
year=a;
month=b;
day=c;
}
void Date::Display()
{
cout<<"日期为："<<endl;
cout<<"\t"<<year<<"年";
cout<<month<<"月";
cout<<day<<"日"<<endl;
}
int main() // 主函数
{
Date a; // 类的对象可以调用类的公有函数
a.Set(2015,1,17);
a.Display();
return 0;
}
设计一个含有4个整数的类，要求能够求出这4个数的最大值和最小值
#include<iostream.h>
class MaxMin4{
private:
int a,b,c,d;
int Max2(int ,int);
int Min2(int ,int);
public:
void Set(int,int,int,int);
int Max4();
int Min4();
};
int MaxMin4::Max2(int x,int y)
{
if(x>y)
return x;
else
return y;
}
int MaxMin4::Min2(int x,int y)
{
if(x<y)
return x;
else
return y;
}
int MaxMin4::Max4()
{
int m,n;
m=Max2(a,b);
n=Max2(c,d);
return Max2(m,n);
}
int MaxMin4::Min4() // 因为这是求自己类中的最小值
{
int m,n;
m=Min2(a,b);
n=Min2(c,d);
return Min2(m,n);
}
void MaxMin4::Set(int x1,int x2,int x3,int x4)
{
a=x1;
b=x2;
c=x3;
d=x4;
}
int main()
{
MaxMin4 maxmin4;
maxmin4.Set(8,6,5,9);
cout<<"输出这4个数的最大值"<<maxmin4.Max4()<<endl;
cout<<"输出这4个数的最小值"<<maxmin4.Min4()<<endl;
return 0;
}
编一个计算机，用c++实现
#include<iostream.h> //命运由我自己安排，谁也不能做主
class JiSuanQi{
private: int A,B,C;
public:
void Put(int x1,int x2) //赋值
{
A=x1;
B=x2;
}
void Display(); //显示
int addition(); //加法
int substraction(); // 减法
int multiplication(); // 乘法
int division(); //触发
};
void JiSuanQi::Display() // 显示
{
cout<<"显示A="<<A<<endl;
cout<<"显示B="<<B<<endl;
}
int JiSuanQi::addition() // 加法
{
C=A+B;
return C;
}
int JiSuanQi::substraction() // 减法
{
C=A-B;
return C;
}
int JiSuanQi::multiplication() // 乘法
{
C=A*B;
return C;
}
int JiSuanQi::division() //除法
{
C=A/B;
return C;
}
int main() //主函数
{
int x1,x2;
JiSuanQi calculation;
cin>>x1>>x2;
calculation.Put(x1,x2);
calculation.Display();
cout<<"加法为：";
cout<<x1<<"+"<<x2<<"="<<calculation.addition()<<endl;
cout<<"减法为：";
cout<<x1<<"-"<<x2<<"="<<calculation.substraction()<<endl;
cout<<"乘法为：";
cout<<x1<<"*"<<x2<<"="<<calculation.multiplication()<<endl;
cout<<"除法为：";
cout<<x1<<"/"<<x2<<"="<<calculation.division()<<endl;
return 0;
}
对象是c++语言程序设计的基本单位，类描述一类问题的共同属性和行为，对象是类的实例，对象是由类作为类型定义的变量；用类定义了对象之后，对象就具有了类的所有性质。也就是说，类的数据成员就是对象的数据成员，类的成员函数就是对象的成员函数。
要创建一个对象，一般要将对象中的数据成员进行初始化和为对象申请必要的存储空间。c++为对象的初始化提供了必要的机制，可以让用户编写初始化程序，就是构造函数。构造函数由系统自动调用，不能有返回值类型，也不能标为void，构造函数一般声明为公有函数，构造函数可以重载。
不用构造函数定义对象就是自动调用无参数构造函数
#include <iostream>
using namespace std;
class Circle{
private:
float r;
public:
Circle(){ //无参构造
r=0;
}
Circle(float x){ //有参构造
r=x;
}
float peri(){
return 2*r*3.1415;
}
float area(){
return r*r*3.1415;
}
};
int main(int argc, char** argv) {
Circle circle1,circle2(2.0); //无参就不用写了，加括号了
cout<<"circle1"<<endl;
cout<<"周长"<<circle1.peri()<<"面积"<<circle1.area()<<endl;
cout<<"circle2"<<endl;
cout<<"周长"<<circle2.peri()<<"面积"<<circle2.area()<<endl;
return 0;
}
析构函数是对象的生命期结束时要执行的一段程序，用来完成对象被删除前的一些清理工作。析构函数不能有任何返回类型，也不能有void，析构函数是无参，不能重载，一个类只能有一个析构函数。
对象复制是c++程序设计的重要能力。复制构造函数，
具有一般构造函数的特性，它只有一个参数，参数类型是本类对象的引用。起功能应该设计为将已知对象的值复制到正在定义的新的同类型对象。
普通构造函数只在对象创建时被自动调用，而复制构造函数可以在下例情况自动调用。用老的对象定义该类的一个新对象时，如果函数的参数是对象，调用该函数时；
#include <iostream>
using namespace std;
class Point{
private:
float x,y;
public:
Point(){
x=0;
y=0;
cout<<"运行无参的构造函数"<<endl;
}
Point(float x1,float x2){
x=x1;
y=x2;
//cout<<"输出点的坐标 "<<x1","<<x2<<endl;
cout<<"运行有参的构造函数"<<endl;
}
Point(Point &objb){
x=objb.x;
y=objb.y;
cout<<"运行复制函数的构造函数"<<endl;
}
~Point(){
cout<<"执行析构函数"<<endl;
}
void Set(float a=0,float b=0){
x=a;
y=b;
}
void Display(){
cout<<"点的位置是：("<<x<<‘,‘<<y<<"）"<<endl;
}
};
int main(int argc, char** argv) {
Point a;
a.Display();
Point b(2.0,2.0);
b.Display();
Point c(a);
c.Display();
a.Set(5,5);
a.Display();
return 0;
}