C++之类和对象

一、类与对象的基本概念

1.结构体与类
区别：为了保护类中数据的安全，在C++中将类中的成员分为两类：私有成员（用private声明）和公园成员（用public声明）。私有成员（包括数据成员和成员函数）只能被类内的成员函数访问，而不能被类外的对象访问；共有成员（包括数据成员和成员函数）即可被类内的成员函数访问，也可以被类外的对象访问。C++规定，在默认情况下（即没有指定属于私有或公有时），类中的成员是私有的。C++结构体中的成员同样可以分为私有成员和公有成员，但在默认情况下，结构体中的成员是共有的。
例：含有公有成员和私有成员的Complex的类：

#include<iostream>
#include<cmath>
using namespace std;
class Complex//声明了一个名为Complex的类
{
 private://声明以下部分为私有的
     double real;//私有数据成员
     double imag;
 public://声明以下部分为公有的
     void init(double r,double i)//公有成员函数，作为类的外部接口
     {
       real=r;
       imag=i;
     }
    double abscomplex()
    {
      double t;
      t=real*real+imag*imag;
      return sqrt(t);
    }
};
int main()
{
  Complex A;//定义类Complex的对象A
  A.init(1.1,2.2);//类外的对象A可以访问公有成员函数init
  cout<<"复数的绝对值是："<<A.abscomplex()<<endl;
  return 0;  
}

类类型的说明的一般形式如下：

class 类名
{
[private:]
      私有数据成员和成员函数
public:
      公有数据成员和成员函数
}；

补充：类和结构体的功能基本上相同。那么，何必多此一举，在C++中设两种功能一样的类型呢？
这主要是考虑到设计C++语言的一条原则，即C++必须兼容C，要使得以前用C编写的已在广泛使用的C程序能够不加修改地在C++的环境下使用。所以，在C++中必须保留C结构体这种数据类型，并对其功能进行了扩充。
注意：（1）数据成员可以是任何数据类型，但是不能用自动（auto）、寄存器（register）或外部（extern）进行说明。
二、成员函数的定义:
类的成员函数是函数的一种，它也有函数名、返回值类型和参数表，用法与普通函数基本是一样的，只是它属于一个类的成员。成员函数可以访问本类中任何成员（包括公有的、保护的、私有的）。
成员函数的第一种定义方式是：在类声明中只给出成员函数的原型，而将成员函数的定义放在类的外部。这种成员函数的定义放在类的外部。这种成员函数在类外定义的一般形式是：

返回值类型  类名::成员函数名（参数表）
{
 函数体
}

例如：表示坐标点的类Point可声明如下：

class   Point
{
  public:
     void  setpoint (int,int);
     int getx();
     int gety();
   private:
     int x,y;
};
void Point::setpoint(int a,int b)
{
x=a;
y=b;
}
int Point::getx()
{
return x;
}
int Point::gety()
{
return y;
}

注意：
（1）在类外定义成员函数时，必须在成员函数名之前缀上类名，在类名和函数名之前加上作用域运算符：：，用于声明这个成员函数是属于哪个类的。
::getx()或getx()
则表示getx函数不属于任何类，这个函数不是成员函数，而是普通函数。
（2）采用“在类声明中只给出成员函数的原型，而将成员函数的定义放在类的外部”的定义方式，是C++程序设计的良好习惯。C++编译器将函数setpoint、getx、gety作为内联函数进行处理，即将这些函数隐含地定义为内联成员函数。
（3）使用内联函数时，必须将类的声明和内联成员函数的定义都放在用一个文件中，否则编译时无法进行代码置换
三、对象的定义及使用
C++把类的变量叫做类的对象，对象也称为类的实例。
对象的定义：
（1）在声明类的同时，直接定义对象

class Point
{
  public:
    void setpoint(int,int);
    int getx();
    int gety();
  private:
    int x,y;
}op1,op2;//直接定义对象op1,op2

（2）声明了类之后，在使用时再定义对象。

Point op1,op2;

说明：
声明了一个类便声明了一种类型，它并不接收和存储具体的值，只作为生成具体对象的一种“样板”，只有定义了对象后，系统才为对象分配存储空间，以存放对象中的成员。
（3）对象中成员的访问
a.通过对象名和对象选择符访问对象中的成员： 对象名.数据成员名
或对象名.成员函数名。其中“.”叫做对象选择符，简称点运算符。
例：通过对象名和对象选择符访问对象中的成员

#include<iostream>
using namespace std;
class Point{
private:
  int x,y;
public:
  void setpoint(int a,int b)
  {
  x=a;
  y=b;
  }
  int getx()
  {
  return x;
  }
  int gety()
  {
  return y;
  }
};
int main()
{
Point op1,op2;
int i,j;
op1.setpoint(1,2);
op2.setpoint(3,4);
i=op1.getx();
j=op1.gety();
cout<<"op1 i="<<i<<"  op1 j="<<j<<endl;
i=op1.getx();
j=op1.gety();
cout<<"op1 i="<<i<<"  op1 j="<<j<<endl;
return 0;
}
运行结果：
op1 i=1 op1 j=2
op2 i=3 op2 j=4

说明:在类的内部所有成员之间都可以通过成员函数直接访问，但类的外部不能访问对象的私有成员。

int main()
{
Point op;
int i,j;
op.setpoint(1,2);
i=op.x;//不能直接访问对象的私有成员x，y
j=op.y;
cout<<"op x="<<i<<"  op y="<<j<<endl;
}

改为：

i=op.getx();
j=op.gety();

运行成功
（2）通过指向对象的指针访问对象中的成员
例如:

class Date
{
public:
    int year;
};
.......
Date d,*ptr;//定义对象d和指向类Date的指针变量ptr
ptr=&d;//使ptr指向对象d
cout<<ptr->year;//输出ptr指向对象中的成员year

在此，ptr->year表示ptr当前指向对象d中的成员year，因为（*ptr）就是对象d,(*ptr).year表示的也是对象d中的成员year。所以
d.year
(*ptr).year
ptr->year三者等价
（3）通过对象的引用访问对象中的成员
例如：

class Date{
public:
   int year;
};
....
Date d1;//定义类的对象d1
Date &d2=d1;//定义类的引用d2,并用对象d1进行初始化
cout<<d1.year;
cout<<d2.year;//两个值相同