高级语言程序设计第三章 C ＋＋语言基础－对象

周律

教学目标 类对象 构造函数 析构函数 拷贝构造函数 指针的概念 指向类成员的指针 指向类静态成员的指针 对象指针、 This 指针、常指针等 对象的其它知识：常类型，子对象，动态内存的

分配

类对象为了使用类，还必须说明类的对象。在定义

类时，系统是不会给类分配存储空间的，只有定义类对象时才会给对象分配相应的内存空间。对象的定义格式：

< 类名 > < 对象名表 > ；其中， < 类名 > 是待定的对象所属的类的名字，即

所定义的对象是该类的对象。 < 对象名表 > 中可以有一个或多个对象名，多个对象名用逗号分隔。在 < 对象名 > 中，可以是一般的对象名，还可以是指向对象的指针名或引用名，也可以是对象数组名。

对象成员

对象成员的表示方法一个对象的成员就是该对象的类所定义的成

员。对象成员有数据成员和成员函数。一般对象的成员表示如下：

< 对象名 >.< 成员名 >或者

< 对象名 >.< 成员名 > （ < 参数表 > ）前者用于表示数据成员，后者用于表示成员

函数。这里的“ .” 是一个运算符，该运算符的功能是表示对象的成员。

示例

#include <iostream.h>class myclass{public:

int data1;};void main(){

myclass object1;object1.data1 = 25;cout << "\n data1 的值是 " << object1.data1<<"\n";

}

对象指针的成员指向对象的指针的成员表示如下：

< 对象指针名 >->< 成员名 >或者

< 对象指针名 >->< 成员名 > （ < 参数表 > ）同样，前者用于表示数据成员，后者用于表示成员函数。

这里的“ ->” 是一个表示成员的运算符，它与前面介绍过的“ .” 运算符的区别是：“ ->” 用来表示指向对象的指针的成员，而“ .” 用来表示一般对象的成员。

对于数据成员和成员函数，以下两种表示方式是等价的：< 对象指针名 >->< 成员名 >

与 （ *< 对象指针名 > ） .< 成员名 >

示例#include <iostream.h>class myclass{public:

int data1;};void main(){

myclass objact1;myclass *pObject1 = &objact1;pObject1->data1 = 25;cout << "\n data1 的值是 " <<pObject1->data1<<"\n";

}

构造函数自动初始化对象的特殊的成员函数与所属的类同名可以在类中声明并定义构造函数，或在类

中声明而在外部定义构造函数没有返回类型默认构造函数是不带任何参数的构造函数

示例 1class IMTI {

public:

IMTI(); // 构造函数};

IMTI() :: IMTI()() { }

示例 2

class date{ int month, day, year;public: date() //默认构造函数 {day=1; month=1; year=1999;} date(int x) //仅指定日 {day=x; month=1; year=1999;} date(int x, int y, int z) // 指定年月日 {day=x; month=y; year=z;}};

缺省构造函数 缺省构造函数是指不需要用户指定实参就能够被调用的构造函数，这并不意味着它不能接受实参。只意味着构造函数的每个参数都有一个缺省值与之关联。如：

Account::Account() { ... } Stack::Stack( int size = 0 ) { ... } Complex::Complex(double re=0.0,double

im=0.0) { ... }

构造函数

编译器根据参数调用不同的构造函数date now;

date today(4);

date all(23,3,1998);

析构函数

在对象销毁时自动调用的成员函数 编译器会生成对析构函数的调用 与类同名，但是在函数名前有个波浪号 (~) 析构函数没有返回类型，也不带参数 一个类中只可能定义一个析构函数。

示例 1class imti {public:

~ imti ();// 析构函数};

IMTI() :: ~IMTI()() { }

示例 2#include<iostream.h> class Sample { public:

Sample() {x = 0;} ~Sample() {

cout<<" 析构函数被调用！ "<<endl; } int x; void Print() {

cout<<"x = "<<x<<endl; }

}; void main() {

Sample s1; s1.Print(); s1.~Sample();

}

缺省析构函数

缺省析构函数的格式如下：< 类名 >::~< 缺省析构函数名 >{ }< 缺省构析函数名 > 即为该类的类名。缺省析构

函数是一个空函数

拷贝构造函数

　在下列情况，会调用拷贝构造函数 把某个对象初始化为类的另一个对象时 将对象当作参数传递给函数时 函数返回对象时

拷贝构造函数

如果没有定义拷贝构造函数，编译器将自动生成一个

自动生成的拷贝构造函数只是将对象内容逐个字节地 copy

当数据成员有指针时，将导致两个对象的指针指向同一个地址

拷贝构造函数

定义以对象的引用作为参数的构造函数

X::X(X &ptr)

或X::X(const X &ptr)

使用 const 关键字，可以确保拷贝过程不会意外地更改源对象

示例 1

#include<iostream.h>class TPoint{public:

TPoint(int x, int y){ m_x = x; m_y = y;}TPoint(TPoint & p);~TPoint(){cout<<"Destructor Called ！ \n";}int Xcoord() {return m_x;}int Ycoord() {return m_y;}

private:int m_x, m_y;

};

示例 1 （续）

TPoint::TPoint(TPoint & p){

m_x = p. m_x;m_y = p. m_y;cout<<"Copy-initialization Constructor Called.\n,";

}void main(){

TPoint p1(5, 7);TPoint p2(p1);cout<<"p2 = "<<p2.Xcoord()<<","<<p2.Ycoord()<<endl;

}

示例 2#include<iostream.h>class TPoint{public:

TPoint(int x, int y){ m_x = x;m_y = y;cout<<"now is beginning"<<endl;

}TPoint(TPoint & p);~TPoint(){cout<<"Destructor Called ！ \n";}int Xcoord() {return m_x;}int Ycoord() {return m_y;}

private:int m_x, m_y;

};

示例 2 （续）TPoint::TPoint(TPoint & p){

m_x = p. m_x;m_y = p. m_y;cout<<"Copy-initialization Constructor Called.\n,";

}TPoint F(TPoint q){

cout<<"ok\n";int x, y;x = q.Xcoord() + 10;y = q.Ycoord() + 20;TPoint R(x, y);return R;

}void main(){

TPoint a(20, 35), b(0, 0);TPoint n(a);b=F(n);cout<<"b="<<b.Xcoord()<<","<<b.Ycoord()<<endl;

}

程序中 : int i;

float k;

内存中每个字节有一个编号 ----- 地址

….

..…

...

2000

2001

2002

2005

内存0

2003

i

k

编译或函数调用时为其分配内存单元

变量是对程序中数据存储空间的抽象

指针的概念

….

..…

...

2000

2004

2006

2005

整型变量 i

10

变量 i_pointer

2001

2002

2003

指针：一个变量的地址指针变量：专门存放变量地址的变量叫 ~

2000

指针

指针变量

变量的内容 变量的地址

指针变量

变量

变量地址 ( 指针 )

变量值

指向 地址存入指针变量

指针的概念

& 与 * 运算符含义

含义 : 取变量的地址单目运算符优先级 : 2结合性 : 自右向左

含义 : 取指针所指向变量的内容单目运算符优先级 : 2结合性 : 自右向左

两者关系：互为逆运算理解

….

..…

...

2000

2004

2006

2005

整型变量 i

10

变量 i_pointer

2001

2002

2003

2000 指针变量

i_pointer-----指针变量，它的内容是地址量*i_pointer----指针的目标变量，它的内容是数据&i_pointer---指针变量占用内存的地址

2000 10

i_pointer *i_pointer

&i_pointer

i

i_pointer &i &(*i_pointer)i *i_pointer *(&i)

i_pointer = &i = &(*i_pointer)i = *i_pointer = *(&i)

指针的概念

面向对象元素与指针

指向类成员的指针 ：

指向数据成员的指针：

< 类型说明符 >< 类名 >::*< 指针名 >

示例#include <iostream.h> class Test{ private:

int a; public:

Test(int i) {a = i;}int c;int fun(int b){return a * c + b;}

};

void main(){int Test::*pc = &Test::c;Test object1(1);object1.*pc = 8;cout<<"object1.c is"<<object1.c<<endl;

}

静态类成员指针 静态类成员是属于该类的全局对象和函数。 指向静态成员的指针，声明的方式和普通指针完全一样，

只是赋值的时候，还得加上类的限定符：

#include<iostream.h>class myclass {public: // 构造函数 , 每定义一个对象 , 静态数据成员 i加 1

myclass() { ++i; }static int i; // 声明静态数据成员 i

}; int myclass::i=0; // 静态数据成员 i 初始化 , 不必在前面加 s

taticvoid main(){

int *count=&myclass::i; // 声明一个 int 型指针 , 指向类的静态成员

myclass ob1,ob2,ob3,ob4;cout<<"myclass::i= "<<*count<<endl; // 通过指针直接访问静态

数据成员}

示例

指向成员函数的指针

指向数据成员的指针：

< 类型说明符 >(< 类名 >::*< 指针名 >)(< 参数表 >)

示例#include <iostream.h> class Test{ private:

int a; public:

Test(int i) {a = i;}int c;int fun(){return a+ c;}

};

void main(){Test object1(1);int (Test::*pfun) ();pfun = &Test::fun;object1.c = 8;int x=1;cout<<"object1.*pfun is"<<(object1.*pfun)()<<endl;

}

对象指针1. 用指针访问单个对象成员

声明对象指针的一般语法形式为 : 类名 * 对象指针名 ;

当用指向对象的指针来访问对象成员时 ,

要用“ ->”操作符。

#include<iostream.h>class exe{public: void set_a(int a){ x=a; } void show_a(){ cout<<x<<endl; }private:

int x; };

int main(){ exe ob,*p; // 声明类 exe 的对象 ob 和类 exe 的对象指

针 p ob.set_a(2); ob.show_a(); // 利用对象名访问对象的成员 p=&ob; // 将对象 ob 的地址赋给对象指针 p p->show_a(); // 利用对象指针访问对象的成员 return 0;}

示例

2. 用对象指针访问对象数组 上例的 main() 改写为 :

int main(){ exe ob[2],*p; ob[0].set_a(10);

ob[1].set_a(20); p=ob;

p->show_a(); p++; p->show_a(); return 0;}

对象指针

this 指针 This 指针是指向对象本身的指针，它隐含在类成员函数中，

用来指向成员函数所属类的正在被操作的对象。 编译器会把对象的地址赋给成员函数中的 this 指针。确保访问到的数据成员属于这个对象

Date::Date(int y,int m,int d){

this -> year = y;

this -> month = m;

this -> day = d;

} 注：静态成员函数没有 this 指针

this 的用法class person{private: int age;public: void display();};void Person::display(){ this -> age = 25; // 与 age = 25 一样 cout << this -> age; // 与 cout << age 一样 cout << endl; };int main(){ Person Jack; Jack.display(); return 0;}

对象数组定义：对象数组是指数组元素为对象的数组，该数组中若干个元素必须是同一个类的若干个对象 。对象数组定义格式如下：

< 类名 >< 数组名 >[<大小 >]

比如： Date dates1[7];

示例

class Date{public:

Date(int m, int d, int y);void Printf();

private:int m_month, m_day, m_year;

};Date dates[4] ＝ { Date (4 ， 22 ， 2006) ， Date

(4 ， 23 ， 2006) ， Date (4 ， 24 ， 2006) ， Date (4 ， 25 ， 2006)}

指针与数组对于二维数组，又是如何用指针访问其中的每个数组元

素的呢？例如，定义了一个二维数组 a ：

int a[3][5];a 是以一个 3*5 的二维数组，它有三行，每一行都有其起

始地址。C++ 语言规定以 a[0] ， a[1] ， a[2] 分别表示第 0行，第

1行，第 2行的起始地址，即该行第 0 列元素的地址。注意 a[0] ，a[1] ， a[2] 并不是一个元素，而是一行首地址，正如同一维数组名是数组起始地址一样， a[0] 的值等于 &a[0][0] ， a[1] 的值等于&a[1][0] ， a[2] 的值等于 &a[2][0] 。在同一行中是同样的类推方式，比如： a[0]+1 的值等于 &a[0][1] ， a[1]+2 的值等于 &a[1][2] ，……。

数组指针数组指针与指针数组

在 C++ 语言中，数组指针就是一个指向数组的指针；指针数组就是其元素为指针的数组。在学习 C++ 语言时，要注意对它们进行区分，不能等同起来。

1. 数组指针数组指针是一个指向一维数组的指针变量，定义数组指针的

格式为：数据类型 （ * 指针名） [ 常量表达式 ] ；

数组指针例如：

int (*p)[5];

上面这个语句定义了一个数组指针 p ，它指向一个包含 5 个元素的一维数组，数组元素为整型。注意， *p 两侧的圆括号不能省略，它表示 p 先与星号“ *” 结合，是指针变量。如果省略了圆括号，即写成 *p[5] 的形式，由于方括号的优先级比星号高，则 p 先与方括号 [ ] 结合，是数组类型，那么语句 int *p[5]；是定义了一个指针数组。

指向对象数组的指针指向对象数组的指针定义格式如下：

< 类名 >(*PL)[4];

其中， PL 是指向数组的指针名，该指针是一个指向一维对象数组的指针，该数组中有 4 个元素，每个元素是指定 < 类名 > 的对象

指针数组

2. 指针数组指针数组就是其元素为指针的数组。它是指针的集合，它的每

一个元素都是指针变量，并且它们具有相同的存储类型和指向相同的数据类型。

说明指针数组的语法格式为：数据类型 * 指针数组名 [ 常量表达式 ] ；

其中，数据类型式指数组中各元素指针所指向的类型，同一指针数组中各指针元素指向的类型相同；指针数组名也即数组的首地址，是一个标识符；常量表达式指出这个数组中的元素个数。

例如：下面定义了几个指针数组。int *p1[6];float *p2[3][4];

void 指针void 指针

一般来说，只能用指向相同类型的指针给另一个指针赋值，而在不同类型的指针之间进行赋值是错误的。比如：

int a,b; int *p1=&a,*p2=p1; //正确

而：int a;int *p1=&a;double *p2=p1; //错误上述语句中的两个指针 p1 ， p2 指向的类型不同，因此，

除非进行强制类型转换，否则它们之间不能相互赋值。但是 void指针是一个特例。

void 指针C++ 语言允许使用空类型（ void ）指针，即不指定指针指向

一个固定的类型，它的定义格式为： void *p;

表示指针变量 p 不指向一个确定的类型数据，它的作用仅仅是用来存放一个地址。

void 指针它可以指向任何类型的 C++ 数据。也就是说，可以用任何类型的指针直接给 void 指针赋值。不过，如果需要将 void 指针的值赋给其他类型的指针，则需要进行强制类型转换。比如：

int a; int *p1=&a; void *p2=p1;int *p4=(int *)p2;

对象的其它知识

常类型常引用 如果在说明引用时用 const修饰 , 则被说明

的引用为常引用。 常引用的说明形式如下 : const 类型说明符 & 引用名例如 : int a=5; const int& b=a; 其中 ,b 是一个常引用 ,它所引用的对象不允许更改。

#include<iostream.h>int add(const int& i,const int& j);void main(){

int a=20; int b=30;

cout<<a<<"+"<<b<<"="<<add(a,b)<<endl;}int add(const int& i,const& j){

return i+j;}

实例

常对象 如果在说明对象时用 const 修饰 , 则

被说明的对象为常对象。常对象的说明形式如下 : 类名 const 对象名 [( 参数表 )];或者 const 类名 对象名 [( 参数表 )]; 在定义对象时必须进行初始化 , 而且不

能被更新。

#include<iostream.h> class Sample {public: int m; Sample(int i,int j){ m=i; n=j;} void setvalue(int i){ n=i; } void disply(){ cout<<"m="<<m<<endl; cout<<"n="<<n<<endl;}private: int n;};void main(){ Sample a(10,20);a.setvalue(40); a.m=30; a.disply();}

常对象示例

常指针使用 const 修饰指针时，由于 const 的位置不同，而含意不同：

下面定义的一个指向字符串的常量指针：char *const ptrl = stringptrl

下面定义了一个指向字符串常量的指针 const char*ptr2 = strmgptrl ；

程序所使用的存储区：

1．静态存储区――程序初始化时分配的存储区。

2．栈――局部变量分配的存储区域。

3．堆――自由存储单元，动态分配存储区。

动态内存分配

堆：运算符 new

用于为类的对象创建内存空间如果成功，返回指向所分配内存空间的指针

data_type pointer_variable = new data_type;

例如int *p; // 指向 int 类型的指针float *f; // 指向 float 类型的指针p = new int; //为 int 类型分配内存f = new float; //为 float 类型分配内存

运算符 new

内存空间不足或者检测到错误，返回空new 类似于 C 语言中所使用的 malloc() 函

数对于对象也是同样的语法

Student *stu_ptr; // 指向 Student 类型对象的指针stu_ptr = new Student; // 指向新的 Student 对象

运算符 delete

delete显式销毁由 new创建的对象

int *ptr;

ptr = new int;

*ptr = 12;

cout << *ptr;

delete ptr;

使用完内存后，使用 delete 将其释放不要使用指向已经释放的内存的指针

运算符 delete

分配由变长数组组成的内存块int *ptr;

ptr = new int[100];

delete [] ptr;

使用 new 分配对象数组，必须在 delete 语句中使用 [ ]

使用 delete删除由malloc 分配的内存是错误的

使用 free释放由 new 分配的内存也是错误的

类中的数据成员也可以是指向堆中某一内存单元的指针，内存单元可以由构造函数分配，析构函数来释放#include <iostream.h>class A{public:

A(int x1=0,int y1=0);~A();void setxy(int x1,int y1);void outputxy();

private:int *x,*y;

};

示例

A::A(int x1,int y1){ x = new int(x1);

y = new int(y1);}A::~A(){ delete x;

delete y;}void A::setxy(int x1,int y1){ *x = x1;

*y = y1;}

示例（续）

void A::outputxy(){

cout<<"*x=\t"<<*x<<"\t*y=\t"<<*y<<endl;}void main(){

A *p = new A(1,1);p->outputxy();p->setxy(2,5);p->outputxy();delete p;

}

示例（续）

子对象 如果一个类的对象是另一个类的数据成员 , 则称这样

的数据成员为对象成员。例如 : class A { //... }; class B { A a; // 类 A 的对象 a为类 B的对象成员 public: //… };

例如有以下的类 : class X{ 类名 1 对象成员名 1; 类名 2 对象成员名 2; … 类名 n 对象成员名 n; };类 X 的构造函数的定义形式为 ;

X::X(形参表 0): 对象成员名 1(形参表 1),…,对象成员名 i(形参表 i) ,…,对象成员名 n(形参表 n){ // … 构造函数体}

子对象

对象的生存期 所谓对象的生存期是指对象从被创建开始到被释

放为止的时间。 按生存期的不同对象可分为如下三种：

局部对象：当对象被定义时调用构造函数，该对象被创建，当程序退出定义该对象所在的函数体或程序块时，调用析构函数，释放该对象。

静态对象：当程序第一次执行所定义的静态对象时，该对象被创建，当程序结束时，该对象被释放。

全局对象：当程序开始时，调用构造函数创建该对象，当程序结束时调用析构函数释放该对象。

总结

指针的概念 指针的使用 指针的运算 指向类成员的指针 指向类静态成员的指针 对象指针、数组指针、常指针等 对象的其它知识

面向对象概念回放 抽象 对象 类 包 消息 继承 封装 重裁 重写 多态

面向对象概念回放 抽象：抽象是通过从特定的实例中抽取共同的性质以形成一般化的概

念的过程。 对象：可将对象想象成一种新型变量；它保存着数据，但可要求它对

自身进行操作。 类：是对象的进行一步抽象 包：一组类的集合 消息：对象间通信的信息 继承 ：重新使用接口 封装：把变量 , 函数及其它对象隐藏起来，调用时，不必了解实现

特定功能的详细代码和过程 , 只需给规定参数，就可得到想要的结果 .

多态：对于重载或继承的方法 , 在运行时根据调用该方法的实例的类型来决定选择哪个方法来调用 , 这就是多态