第四讲第四讲类和对象类和对象(3)

程序设计实习(I): C++程序设计序设计实(I)C序设计

第四讲类和对象(3)

成员初始化列表CClass::CClass(){

x=0;

y=1;

}

()(),y(){

CClass::CClass():x(0), y(1){

} //成员初始化列表

?以下情况是必须：

?包含另一个类的成员

?成员是一个常量或是引用

4

class CMember{public:

CMember(int x){...} //显式声明构造函数，如果没有整数初始化

//则无法创建CMember 的一个实例

};

CMember* pm = new CMember; // Error CMember*pm =new CMember(2);CMember pm = new CMember(2); //OK

如果CMember 是另一个类的成员，如果要初始化，必须使用成员初始化列表

class CMyClass{

CMember m_member;public:

CMyClass();

}

CMyClass::CMyClass():m_member(2){5

...}

回顾及内容提要

?主要概念

类对象成员变量?语法细节

引用成员函数的写法?

类、对象、成员变量、成员函数

?引用、成员函数的写法?函数重载、缺省参数?对象的访问权限、友元?成员对象和封闭类?构造函数(复制构造函数)?析构函数、调用时机?const 成员和引用成员?常量对象和常量方法?

静态成员

?

this 指针

6

转换构造函数

?定义转换构造函数的目的是实现类型的自动转换?只有一个参数，而且不是复制构造函数的构造函数，一般就可以看作是转换构造函数

数一般就可以看作是

?当需要的时候，编译系统会自动调用转换构造函数，建立一个无名的临时对象(或临时变量)

7

class Complex {

p g

public: float real, imag;

Complex( double f ) {

cout << "FloatConstructor called" << endl;

real = f ; imag = 0;

}

Complex( int i = 0 ) {

C l(i t i0){

cout << "IntConstructor called" << endl;

real=i;imag=0;

real = i; imag = 0;

}

~Complex() {

~Complex(){

cout << "Destructor called" << endl;

}

};

8

Complex c1 ; // Complex(0) c1 = {0, 0};

Complex c2 = 2; // Complex(2) c2= {2, 0}; Complex c2=2;//Complex(2)c2={20};

Complex c3 = 2.5; // Complex(2.5) c3 = {2.5, 0};

int main ()()

{

cout << "c1=" << c1.real << "+" << c1.imag << "i"

<< endl;

cout << "c2=" << c2.real << "+" << c2.imag << "i"

<< endl;

<

cout << "in main" << endl;

;转，时象c1 = 4; //调用转换构造函数，生成临时对象

Complex c4[2]={4, Complex(10)};

cout << "end main" << endl;

return 0;

}

9

输出：

IntConstructor called

IntConstructor called

FloatConstructor called

c1=0+0i

10+0i

c2=2+0i

in main

in main

IntConstructor called //调用转换构造函数

Destructor called // 临时对象消亡

IntConstructor called

IntConstructor called

end main

end main

Destructor called

Destructor called

Destructor called

Destructor called

Destructor called

Destructor called

10

Complex c1 ; // Complex(0) c1 = {0, 0};

Complex c2 = 2; // Complex(2) c2= {2, 0}; Complex c2=2;//Complex(2)c2={20};

Complex c3 = 2.5; // Complex(2.5) c3 = {2.5, 0};

int main ()()

{

cout << "c1=" << c1.real << "+" << c1.imag << "i"

<< endl;

cout << "c2=" << c2.real << "+" << c2.imag << "i"

<< endl;

<

cout << "in main" << endl;

p;时象

Complex c = 4; //不生成临时对象

Complex c4[2]={4, Complex(10)};

cout << "end main" << endl;

return 0;

}

11

输出：

IntConstructor called

IntConstructor called

FloatConstructor called

c1=0+0i

10+0i

c2=2+0i

in main

in main

IntConstructor called

IntConstructor called

IntConstructor called

end main

Destructor called

Destructor called

Destructor called

Destructor called

Destructor called

Destructor called

Destructor called

Destructor called

12

1) 定义常量

)常

const int MAX_V AL = 23；

const string SCHOOL_NAME = “Peking University”；

2) 在指针定义上，则不能通过该指针修改其指向的地方的内容

int n, m;

const int * p = & n;

* p = 5; //编译出错

n = 4; //ok

p = &m; //ok

注意：不能把常量指针赋值给非常量指针，反过来可以

注意不能把常量指针赋值给非常量指针反过来可以const int * p1; int * p2;

p1 p2; //ok

p1=p2;

p2 = p1; //error

p2 = (int * ) p1; //ok

13

如果不希望在函数内部不小写了改变参数指针所指地方的 如果不希望在函数内部不小心写了改变参数指针所指地方的内容的语句，那么就可以使用常数指针参数

void MyPrintf( const char * p )

{

strcpy( p, "this"); //编译出错

strcp(p"this");

cout<

}

3) 用在引用上

int n;

const int & r = n;

r = 5; //error

n = 4; //ok

14

如果不希望某个对象的值被改变则定义该对象的时候可以常量对象和常量方法

如果不希望某个对象的值被改变，则定义该对象的时候可以在前面加const 关键字

class Sample {

private :

int value;int value;public:

void SetValue() {vo d Se V ue(){}

};

常对象

const Sample Obj; // 常量对象Obj.SetValue (); //错误！常量对象只能使用构造函数、析构函const 数和有const 说明的函数(常量方法）

15

?在类的成员函数说明后面可以加const关键字，则该成员函数成为常量成员函数

?常量成员函数内部不能改变属性的值，也不能调用非常量成员函数

class Sample {

l S l{

private :

int value;

int value;

public:

void func() { };

void SetValue() const{

value = 0; // wrong

func(); //wrong

f()//

}

};};

const Sample Obj;

Obj.SetValue (); //常量对象上可以使用常量成员函数16

在

定义常量成员函数和声明常量成员函数时都应该使用const 关键字

class Sample {

class Sample{

private :

int value;;

public:

void SetValue() const;

};

void Sample::SetValue() const{ //此处不使用const会

//导致编译出错

cout << value;

}

17

觉递个对象复构

const 的用法

如果觉得传递一个对象效率太低(导致复制构造函数调用，还费时间)又不想传递指针，又要确保实际参数的值不能在函数中被修改，那么可以使用:

const T & 类型的参数

void PrintfObj( const Sample & o ){

o.func(); //error o.SetValue(); //ok

Sample & r = (Sample &) o; //必须强制类型转换r.func(); //ok }

18

常量成员函数的重载

两个函数，名字和参数表都一样，但是一个是const，一个不是，算重载

个不是算重载

19

class CTest {

private :

int n;

public:

CTest() { n = 1 ; }

CTest(){n=1;}

int GetValue() const { return n ; }

(){;}

int GetValue() { return 2 * n ; } };

int main() {

const CTest objTest1;

CTest objTest2;

cout << objTest1.GetValue() << , <<

cout<

objTest2.GetValue() ;

return 0;;

}

输出: 1, 2

20

(l i )成员对象和封闭类

有成员对象的类叫封闭(enclosing)类

class base1 {

private:

int i;

public :

p base1 ( ) { i = 0; }

};

class base2 {

private:

int i;int i;

public :

base2 (int n) { i = n ; }(){;}

};

21

class Big {

class Big{

private:

int n;

base1 b1; // 成员对象

对象

base2 b2, b3; // 成员对象public:

Big ( ) : b2(1), b3(2) {

}

};

Big b; // 如果不定义构造函数则编译出错

22