/*类和对象
1.类和实例化定义类声明类定义成员函数数据成员的赋值使用类的对象。
2.构造函数数据封装默认构造函数定义构造函数构造函数和元运算符new构造函数的默认参数
复制构造函数析构函数和运算符delete默认析构函数调用复制构造函数的综合实例。
3.成员函数的重载及默认参数
4.this指针
5.一个类的对象作为另一个类的成员
6.类和对象的性质（空类类作用域）
7.标记图UML标记图
8。编译指令嵌入指令宏定义条件编译指令define操作符
9.条件编译。
作业题、、
*/
/*4.8类和对象的性质
对象的性质：
1.同一个类的对象直接可以相互赋值，Point A,B;B=A;
2.可使用对象数组。Point A[3];
3.可使用指向对象的指针，使用取地址&讲一个对象的地址至于这个指针中。Point * p=&A
p->Display();
4.对象可以用作函数参数，
1.如果参数传递采用传对象值的方式如果参数传递采用传对象值的方式
在被调用函数中对形参所作的改变不影响调用函数中作为实参的对象。
2.如果传的是对象的引用当参数对象被修改时，相应的实参也将被修改。
3.如果传值是对象的地址值，可以使用对象指针作为函数参数，为了避免被调用函数修改原来对象的数据成员可以使用const修饰符。
5.对象可以作为函数的参数。可以使用对象，对象引用和对象指针。
6.一个对象可以用作另一个类的成员
类的性质：
1.类本身的成员函数可以使用类的所有成员私有和共有成员。
2.类的对象只能访问共有成员函数
3.其他函数不能使用类的私有成员。也不能使用使用
4.虽然一个类可以包含另外一个类的对象但这个类也只能通过被包含的对象使用哪个类
2.不完全的类声明。
class MemberOnaly;//不完全的类声明
MemberOnaly * cludb;
3.空类
尽管类的目的是封装和数据他可以产生空类对象。
class Empty{
}
没有声明行为但是可以产生空类的对象。
4.类作用域
{}花括号里面
4.9面向对象的标记图
类和对象的UML标记图。
OOP面向对象
OOA面向对象分析
OOD面向对象设计。
对象的结构与连接：
对象结构是指对象之间的分类（继承）和组合（聚合）关系称为关联关系。
对象之间的静态关系是通过对象属性之间的连接反应的称为实例连接
对象行为之间的动态关系是通过对象行为之间的依赖关系表现称之为消息连接。
消息连接和实例统称为连接。
使用实例
4.9.4
1有一个状态，由与其关联的属性值结合所表征。
2.有唯一标识名，可以qu
2.有唯一标示名，每个操作决定对象的一种行为。
3.对象的状态只能被自己的行为所改变
编译指令C++的源程序可包含各种编译指令
1.嵌入指令#include
2.宏定义
#define
3.条件编译指令
4。#define操作符
#ifdef head
#define head
#endif
*/
//#if !defined(i)
//#define i//前两句是什么意思啊？？
//#else
/*作业题
1.数据成员和成员函数。
2.类名重载一个
3.fun:fun(fun &)
fun:fun(const fun &)
二。选择题
1.class是能封装C++的关键字
2.C
3. Point::~Point()
4，B
5.C
6.C
7.D当用new运算符动态产生类的对象时，new运算符也是自动调用构造函数、
三，改错题
return m.
2.最后一个没有return
3完成程序题
1，
#include
using namespace std;
class base
{
private:
int x,y;
public:
void print();
voidinit(int,int);
};
void base::init(int a, int b)
{
x=a;
y=b;
}
void base::print()
{
cout<
}
int main()
{
base a;
a.init(68,66);
a.print();
}
2.完成下面类中的长远函数的定义
#include
using namespace std;
class Point{
private:
int m,n;
public:
Point (int,int);
Point(Point &);
};
Point::Point(int a,int b)
{
m=a;
n=b;
cout<
}
Point ::Point(Point &t)
{
m=t.m;
n=t.n;
cout<
}
int main()
{
Point C(12,324);
Point D(C);
}
*/
/*4.7一个类的对象作为另一个类的成员
#include
using namespace std;
class Point{
int x,y;
public:
void set(int a,int b)
{
x=a;
y=b;
}
int GetX()
{
return x;
}
int GetY()
{
return y;
}
};
class Rectangle{
Point Loc;
intH,W;
public:
void set(int x,int y,int h,int w);
Point * getLoc();
int getHeight(){
return H;
}
int getWeight()
{
return W;
}
};
void Rectangle::set(int x, int y, int h, int w)
{
Loc.set(x, y);
H=h;W=w;
}
Point * Rectangle::getLoc(){
return &Loc;
}
int main()
{
Rectangle rect;
rect.set(10, 10, 25, 30);
cout<
Point * p=rect.getLoc();
cout<GetX()<<"---"<GetY();
}
五程序分析题一
#include
using namespace std;
class base{
private:
int a,b;
public:
~base(){
cout<<"析构函数"<
}
base (int a,int b)
{
cout<<"初始化"<
}
};
int main()
{
base(12, 12);
}
五程序分析题二
#include
using namespace std;
class base{
private:
int x;
public:
void setx(int a){
x=a;
}
int getx()
{
return x;
}
};
int main()
{
int * p;
base a;
a.setx(55);
p=new int(a.getx());
cout<<*p;
}
六编程题
1.设计一个点类Point再设计一个矩形类。矩形类使用Point类的两个坐标点作为矩形的对角订单，并可以输出4个坐标值和面积，使用测试程序验证程序。
2.使用内联函数设计一个类，用来表示指教坐标系中的任意一条直线并输出它的属性。
七。作图题
1.假设不涉及操作，已经定义了类line使用继承的方法组成Rectangle类。
2.假设不涉及操作，已经定义了类Line使用聚合的方法组成Rectangle类。
*/
/*七作图题
1.假设不涉及操作，已经定义了类line使用继承的方法组成Rectangle类。
*/
/*七作图题
2.假设不涉及操作，已经定义了类Line使用聚合的方法组成Rectangle类。
*/
/* 2.使用内联函数设计一个类，用来表示指教坐标系中的任意一条直线并输出它的属性。
#include
#include
using namespace std;
class LineS{
private:
int x,y,x2,y2;
public:
LineS();
LineS(int =0,int=0,int =0,int =0);
void printPoint();
double getLength();
};
LineS::LineS(int a,int b,int c,int d)
{
x=a;
}
inline void LineS::printPoint()
{
cout<
cout<
}
inline double LineS::getLength()
{
double length;
length=sqrt((x2-x)*(x2-x)+(y2-y)*(y2-y));
return length;
}
int main()
{
LineS line(10,80,-10,12);
line.printPoint();
cout<
}
*/
/* 1.设计一个点类Point再设计一个矩形类。矩形类使用Point类的两个坐标点作为矩形的对角订单，并可以输出4个坐标值和面积，使用测试程序验证程序。
#include
using namespace std;
class Point
{
private:
int x, y;
public:
Point()
{
x=0;
y=0;
}
Point(int a,int b)
{
x=a;
y=b;
}
void setXY(int a,int b)
{
x=a;
y=b;
}
int getX()
{
return x;
}
int getY()
{
return y;
}
};
class Rectangele//矩形
{
private:
Point point1,point2,point3,point4;
public:
Rectangele();
void init()
{
point2.setXY(point4.getX(), point1.getY());
point3.setXY(point1.getX(), point4.getY());
}
Rectangele(Point one,Point two)
{
point1=one;
point4=two;
init();
}
Rectangele(int x1,int y1,int x2,int y2)
{
point1.setXY(x1, y1);
point4.setXY(x2, y2);
init();
}
void printPoint()
{
cout<<"A"<
cout<<"B"<
cout<<"C"<
cout<<"D"<
}
int getArea()
{
int height,width,area;
height =point1.getY()-point3.getY();
width=point1.getX()-point2.getX();
area=height* width;
if (area>0) {
return area;
}
else
{
return -area;
}
}
};
int main()
{
Point p1(-15,56),p2(89,-10);
Rectangele r1(p1,p2);
Rectangele r2(1,5,5,1);
cout<<"矩形"<
r1.printPoint();
cout<<"矩形r1的面积"<
r2.printPoint();
cout<<"矩形的面积"<
}
*/
/*4.6this指针隐藏着的this
void Point::setxy(int a,int b,(Point *)this)
{
this->x=a;
this->y=b;
}
*/
/*4.5成员函数重载以及默认参数
class MAX{
private:
int a,b,c,d;
int maxi(int,int);
public:
void Set(int,int,int,int);
int maxi();
}A[3];//声明类的对象数组，定义结束
int MAX::maxi(int x, int y)
{
return (x>y)?x:y;
}
void MAX::Set(int x1=0, int x2=0, int x3=0, int x4=0)
{
a=x1;
b=x2;
c=x3;
d=x4;
}
int MAX::maxi(){
int x=maxi(a, b);
int y=maxi(c, d);
return maxi(x, y);
}
#include
using namespace std;
int main()
{
A[0].Set(12, 23, 45, 56);
A[1].Set(12, 45, 79);
A[2].Set(12, 45);
for (int i=0; i<3; i++) {
cout<
}
}
*/
/*默认析构函数
Point::~Point()
调用复制函数的综合实例
#include
using namespace std;
class Point{
private:
int x,y;
public:
Point(int a=0,int b=0)
{
x=a;y=b;cout<<"构造函数"<
}
Point (const Point &p);
int Getx(){
return x;
}
int GetY(){
return y;
}
void show()
{
cout<
}
~Point()
{
cout<<"delete"<
}
};
Point::Point(const Point &p)
{
x=p.x;
y=p.y;
cout<<"copy"<
}
void display(Point p)
{
p.show();
}
void disp(Point &p)
{
p.show();
}
Point fun()
{
Point A(101,23);
return A;
}
int main()
{
Point A(42,35);
Point B(A);
Point C(58,95);
cout<<"dispaly(b)"<
display(B);
cout<<"dis(b)"<
disp(B);
cout<<"fun "<
C=fun();
cout<<"DSA"<
disp(C);
}
*/
/*析构函数和运算符delete
#include
using namespace std;
class Point
{
private:
int x,y;
public:
Point(int=0,int =0);
~Point();
};
Point::Point(int a,int b):x(a),y(b)
{
cout<
}
Point::~Point()
{
cout<<"默认"<
}
int main()
{
Point * p=new Point[2];
delete []p;
}
*/
/*4.7构造函数的默认参数
#include
using namespace std;
class Point {
private:
int x,y;
public:
Point(int=0,int =0);
};
Point::Point(int a,int b):x(a),y(b){
cout<<"构造函数"<
}
int main()
{
Point A;
Point B(15,24);
Point c[2];
}
*/
/*4.2.5复制构造函数
A::A(A&)
A::A(const A&)
Point (Point& t)
*/
/*析构函数
定义析构函数
~Point()
{
cout<<"自动调用析构函数"
}
voidmain()
{
Point A(3,4);
cout<<"main"<
}
*/
/*4.5使用前面定义的Point类演示全局对象的例子
构造函数和运算符new
4.6
#include
using namespace std;
class Point{
private:
int x,y;
public:
Point();
Point(int,int);
};
Point::Point():x(0),y(0)
{
cout<<"默认"<
}
Point::Point(int a,int b):x(a),y(b)
{
cout<
}
int main()
{
//演示new运算符和构造函数的关系。
Point * p=new Point;
Point * p2=new Point(5,7);
delete p;
delete p2;
return 0;
}
*/
/* 2.构造函数数据封装默认构造函数定义构造函数构造函数和元运算符new构造函数的默认参数
复制构造函数析构函数和运算符delete默认析构函数调用复制构造函数的综合实例。*/
/*默认构造函数Point::Point()*/
/*定义构造函数
#include
using namespace std;
class Point{
private:
int x,y;
public:
Point();
Point(int,int);
};
Point::Point():x(0),y(0)
{
cout<<"默认"<
}
Point::Point(int a,int b):x(a),y(b)
{
cout<
}
int main()
{
Point A;//使用不带参数的构造函数产生对象A
Point B(15,25);//使用带参数的构造函数产生对象B
Point C[2];//使用不带参数的构造函数产生对象数据C
Point D[2]={Point(5,7),Point(8,12)}; //使用带参数的构造函数产生对象数组D
}
*/
/* 1.类和实例化定义类声明类定义成员函数数据成员的赋值使用类的对象
class类名{
private:私有数据和函数
public:共有数据和函数
protected:保护数据和函数
}
4.1
class Point{
private:
int x,y;
public:
void setXy(int a,int b);
void Move(int a,int b);
};
2定义成员函数
。*/
//void Point::setXy(int a,int b)
//{
//x=a;y=b;
//}
/*内联函数
inline int Point::Getx()
{
return x;
}
*/
//数据成员的赋值
/*数据成员的复制不能在类内给数据成员赋值*/
/*使用类的对象
Point A,B;Point *p=&A; Point &R=B;
*/
/*4.2根据Point的定义演示使用Point类的对象
#include
using namespace std;
class Point{
private:
int x,y;
public:
void setXy(int a,int b);
void Move(int a,int b);
void Display();
};
void Point::setXy(int a,int b)
{
x=a;y=b;
}
void Point::Display()
{
cout<
}
//对象指针名->运算符访问对象的成员对象指针名->对象成员名
*/
/*4.3例子Point
#include
using namespace std;
class Point
{
private:
int x,y;
public:
void setXY(inta,int b)
{
x=a;y=b;
}
void Move(int &a,int &b)
{
x=x+a;
y=y+b;
}
void Display()
{
cout<
}
int Getx()
{
return x;
}
int GetY()
{
return y;
}
};
void print (Point * a)
{
a->Display();
}
void print(Point &a)
{
a.Display();
}
int main()
{
Point A,B,*p;
Point &RA=A;
int a=25;
int b=25;
A.setXY(a, b);
B=A;
p=&B;
p->Display();
int c=-80;
int d=23;
RA.Move(c,d);
print(A);
print(&A);
return 0;
}
*/
