类和对象

类的定义
类是对具有相同属性和行为的一类客观事物的概括描述。是用户自定义的数据类型。类的定义包括行为和属性两个部分。属性以数据表示，行为通过函数实现。
C++类定义的格式：
class 类名
{
public:
公有数据成员和成员函数；
protected:
保护数据成员和成员函数；
private:
私有数据成员和成员函数；
}; 分号不能省略
各成员函数的实现；
注意事项
● 类的数据成员可以是其他类的对象，但不能以类自身的对 象作为本类的成员，而类自身的指针和引用可以作为类的成员。
●类定义必须以分号“；”结束。
●类与结构体的区别：
没有明确指定类成员的访问权限时，C++结构体的成员是公有的，而类的成员是私有的。
●private只能在类内使用，（更安全）
●一般实现功能的成员函数都是公有的，数据成员是私有的
●类名的第一个字母要大写，有些在类名前加大写的C
类的起名要望文知意
●类的数据成员可以是其他类的对象
访问控制
类的访问属性有:
Public:类的外部接口
Protected:仅允许本类成员函数及派生类成员函数访问(本身及它的后代可以访问）
Private:仅允许本类成员函数访问
成员函数
类的成员函数是实现类的行为属性的成员。
一般将成员函数声明为函数原型，在类外具体实现成员函数。
返回值类型 类名::成员函数名(参数表)
{
函数体
}

class Point 
{
public:  
 float GetPointx();
 float GetPointy();
 void InitPoint(float PointA_x, float PointA_y); 
 void Move(float New_x, float New_y);
private:
  float P1_x,P1_y;
}；
void Point::InitPoint(float PointA_x, float PointA_y) 
{
 P1_x=PointA_x;
 P1_y=PointA_y;
}
void Point::Move(float New_x, float New_y) 
{
 P1_x+=New_x;
 P1_y+=New_y;
}
float Point::GetPointx()
 {
 return P1_x;
}
float Point::GetPointy()
{
 return P1_y;
}

Point::限定成员函数都属于Point类
成员函数可以操作的数据
●本类的数据成员
●函数内定义的局部变量
●全局变量（不好，在面向对象里不建议使用）
类的成员函数通过操作数据成员来实现功能
成员函数加不加形参问题：
如果操作需要从外界引入数据 加形参；如果只对数据成员操作 不加形参
对象
●对象是类的实例或实体。
●类与对象的关系，如同C++基本数据类型和该类型的变量之间的关系。
对象的定义 格式
类名 对象名1，对象名2，…，对象名n；
定义对象应注意
●必须在定义了类之后，才可以定义类的对象。
**类成员的访问 **
对象成员的访问包括：
●圆点访问形式：对象名.公有成员
●指针访问形式
指针访问形式
对象指针变量名->公有成员

#include<iostream.h>
class  ptr_access  {
public:                         
 void setvalue(float a, float b) { x=a; y=b; }
 float Getx() {return x;}
 float Gety() {return y;}
 void print() 
{
  cout<<"x="<<x<<endl;
  cout<<"y="<<y<<endl;
 }
private:                          //私有数据成员
  float x,y;
};
int main()
{
  float a1,a2;
  ptr_access *ptr=new ptr_access;
       ptr->setvalue(2,8); //通过指针访问公有成员函数
  ptr->print();
  a1=(*ptr).Getx();     
      //通过公有成员函数访问私有数据成员
  a2=(*ptr).Gety();
  cout<<"a1="<<a1<<endl;
        cout<<"a2="<<a2<<endl;
        return 0;
}

类定义和使用时应注意：
1.在类的定义中不能对数据成员进行初始化。
2.类的任何成员都必须指定访问属性，一般将数据成员定义为私有成员或保护成员，将成员函数定义为公有成员。
3.类中的数据成员可以是C++语法规定的任意数据类型。
4.类的成员可以是其他类的对象，称为类的组合。但不能以类自身的对象作为本类的成员。
5.类定义必须以分号“；”结束
6.class与struct的不同：
class中，成员缺省情况是private。
struct中，成员缺省情况是public。
成员函数可以重载
●函数重载：函数名相同，但参数不相同（类型不同，或者个数不同）的一组函数。
●编译器根据不同参数的类型和个数产生调用匹配
●函数重载用于处理不同数据类型的类似任务
构造函数和析构函数**
●构造函数是用于创建对象的特殊的成员函数
当创建对象时，系统自动调用构造函数
●构造函数的作用是：
为对象分配空间；对数据成员赋初值；请求其他资源。
●用户没有定义的构造函数时，系统自动提供缺省版本的构造函数
●构造函数名与类名相同：类名
●构造函数可以有任意类型的参数，但没有返回类型
●析构函数是用于取消对象的成员函数
当一个对象作用结束时，系统自动调用析构函数
●析构函数的作用是进行对象消亡时的清理工作
● 没有用户定义析构函数时，系统提供缺省版本的析构函数
● 析构函数名为： ~ 类名
●析构函数没有参数，也没有返回类型
默认构造函数
如果类中没有定义构造函数，系统将自动生成一个默认形式的构造函数，用于创建对象，默认构造函数形式：
类名::类名(){}
通常,利用构造函数创建对象有以下两种方法:
(1) 利用构造函数直接创建对象.其一般形式为:
类名 对象名[(实参表)];
不带参数：当用户没定义构造函数时，调用默认的构造函数；当用户定义了构造函数时，调用无参的构造函数（没有无参构造函数时要出错！系统不会调用默认构造函数）
带实参表：系统按照重载函数匹配原则，调用对应的构造函数；
为类Date建立一个构造函数

#include <iostream.h>
class Date {
    public:
     Date();     // 无参构造函数
     Date(int y,int m,int d); 
     void showDate();
    private:
            int year, month, day;
    };
Date::Date()    // 构造函数的实现
{  year=0; month=0; day=0; }
Date::Date(int y,int m,int d) 
{ year=y; month=m; day=d; }
inline void Date::showDate()
{  cout<<year<<"."<<month<<"."<<day<<endl; } 
int main()
{
     Date a_date,b_date(2014,3,25);   
     a_date.showDate();
     b_date.showDate();
     return 0;
}

(2) 利用构造函数创建对象时,通过指针和new来实现。其一般语法形式为:
类名 *指针变量 = new 类名[(实参表)];
例如:
Date *date1=new Date(1998,4,28);
就创建了对象(*date1)。

int main()
{
     Date *date1;
            date1=new Date(1998,4,28);     
  //  以上两条语句可合写成:Date *date1=new Date(1998,4,28);
     cout<<"Date1 output1:"<<endl;
     date1->showDate();          
     delete date1;
             return 0;
}

构造函数一定重载
●创建对象时一定要按照构造函数定义的形式创建，参数和类型不匹配的方式不正确
●要创建构造函数就一定要构造一个无参的构造函数
定义构造函数至少写俩
**
构造函数的初始化列表
--------数据成员的初始化
构造函数初始化成员有两种方法:
● A.使用构造函数的函数体进行初始化

class Date
{
 int d, m, y;
public:
 Date(int dd, int mm, int yy)
 {
  d=dd;
  m=mm;
  y=yy;
 }
 Date(int dd, int mm)
 {
  d=dd;
  m=mm;
 }
}

● B.使用构造函数的初始化列表进行初始化
格式:
funname(参数列表):初始化列表
{ 函数体，可以是空函数体 }
初始化列表的形式:
成员名1(形参名1),成员名2(形参名2),成员名n(形参名n)
使用初始化成员列表的形式

class Date
{
 int d, m, y;
public:
 Date(int dd, int mm, int yy)：d(dd),m(mm),y(yy)
  { }
Date(int dd, int mm): d(dd),m(mm)
  { }
}

必须使用参数初始化列表对数据成员进行初始化的几种情况
1.数据成员为常量
2.数据成员为引用类型
3.数据成员为没有无参构造函数的类的对象
类成员的初始化的顺序：
按照数据成员在类中的声明顺序进行初始化，与初始化成员列表中出现的顺序无关
构造函数的调用
构造函数一般被定义为公有成员。
析构函数
析构函数没有返回值，不能有参数，也不能重载
定义格式如下(类外实现)：
类名：：~类名()
{
函数语句
}
析构函数有以下一些特点:
① 析构函数与构造函数名字相同,但它前面必须加一个波浪号(~);
② 析构函数没有参数,也没有返回值,而且不能重载。因此在一个类中只能有一个析构函数;
③ 当撤消对象时,编译系统会自动地调用析构函数。
一般情况下，可以不定义析构函数
但如果类的数据成员中包含指针变量是从堆上进行存储空间分配的话，需要在析构函数中进行存储空间的回收