首页  思维导图  详情

15 友元、异常和其他

2020-02-24 10:28:24   4  举报





AI智能生成

C++ Plus 笔记

C++

作者其他创作

大纲/内容

其他

return Text();//Text是类，是否会创建临时对象问题

#include<iostream>

using namespace std;

class Text{

public:

Text(){cout<<"T created\n";}
Text(const Text & t1){cout<<"T copystructor created\n";}

~Text(){cout<<"T destoryed\n";}

};

Text haha()

{

return Text();

}

int main()

{

Text t1=haha();

return 0;

}

结果

T created

T destoryed

只有一对，表示return Text（）不产生临时对象。

int main()

{

Text t1=haha();

return 0;

}
改成

int main()

{

Text t1；
t1=haha();

return 0;

}

结果

T created

T destoryed

结论

说明在haha()函数中，return Text（）创建对象，只会在main（）视情况而产出。

都没有用到复制构造函数。

友元

友元类

作用

友元类的所有方法都可以访问原始类的私有成员和保护成员

虽然友元被授予从外部访问类的私有部分的权限，但它们不与面向对象的编程思想相矛盾，
提高了公有接口的灵活性

（例子）
电视和遥控

关系

不是has-a,不是is-a

遥控器可以改变电视机的状态（其私有数据决定其状态），
表明应将Remote类作为TV类的一个友元。

格式

class Tv{
public:
firend class Remote;//
.....
};

........
class Remote{
........
};

说明

将Remote类声明为Tv的友元，
Remote成员函数可访问Tv的私有数据.

即：class Tv{
....
private: int channel;
.......};
class Remote:{
public:
.....
void set_chan(Tv & t, int c) {t.channel = c;}
};

Remote类中的成员函数一般用Tv作为参数，说明遥控独立于电视机，
一个遥控器可用于多台电视机。
如果创建一个大型类来包含电视机和遥控器，无法实现一个遥控器可用
于多台电视机。

代码

头文件

// tv.h -- Tv and Remote classes

#ifndef TV_H_

#define TV_H_

class Tv

{

public:

friend class Remote; // Remote can access Tv private parts

enum {Off, On};

enum {MinVal,MaxVal = 20};

enum {Antenna, Cable};

enum {TV, DVD};

Tv(int s = Off, int mc = 125) : state(s), volume(5),

maxchannel(mc), channel(2), mode(Cable), input(TV) {}

void onoff() {state = (state == On)? Off : On;}

bool ison() const {return state == On;}

bool volup();

bool voldown();

void chanup();

void chandown();

void set_mode() {mode = (mode == Antenna)? Cable : Antenna;}

void set_input() {input = (input == TV)? DVD : TV;}

void settings() const; // display all settings

private:

int state; // on or off

int volume; // assumed to be digitized

int maxchannel; // maximum number of channels

int channel; // current channel setting

int mode; // broadcast or cable

int input; // TV or DVD

};

class Remote

{

private:

int mode; // controls TV or DVD

public:

Remote(int m = Tv::TV) : mode(m) {}

bool volup(Tv & t) { return t.volup();}

bool voldown(Tv & t) { return t.voldown();}

void onoff(Tv & t) { t.onoff(); }

void chanup(Tv & t) {t.chanup();}

void chandown(Tv & t) {t.chandown();}

void set_chan(Tv & t, int c) {t.channel = c;}

void set_mode(Tv & t) {t.set_mode();}

void set_input(Tv & t) {t.set_input();}

};

#endif

定义

// tv.cpp -- methods for the Tv class (Remote methods are inline)

#include <iostream>

#include "tv.h"

bool Tv::volup()

{

if (volume < MaxVal)

{

volume++;

return true;

}

else

return false;

}

bool Tv::voldown()

{

if (volume > MinVal)

{

volume--;

return true;

}

else

return false;

}

void Tv::chanup()

{

if (channel < maxchannel)

channel++;

else

channel = 1;

}

void Tv::chandown()

{

if (channel > 1)

channel--;

else

channel = maxchannel;

}

void Tv::settings() const

{

using std::cout;

using std::endl;

cout << "TV is " << (state == Off? "Off" : "On") << endl;

if (state == On)

{

cout << "Volume setting = " << volume << endl;

cout << "Channel setting = " << channel << endl;

cout << "Mode = "

<< (mode == Antenna? "antenna" : "cable") << endl;

cout << "Input = "

<< (input == TV? "TV" : "DVD") << endl;

}

使用

//use_tv.cpp -- using the Tv and Remote classes

#include <iostream>

#include "tv.h"

int main()

{

using std::cout;

Tv s42;

cout << "Initial settings for 42\" TV:\n";

s42.settings();

s42.onoff();

s42.chanup();

cout << "\nAdjusted settings for 42\" TV:\n";

s42.settings();

Remote grey;

grey.set_chan(s42, 10);

grey.volup(s42);

cout << "\n42\" settings after using remote:\n";

s42.settings();

Tv s58(Tv::On);

s58.set_mode();

grey.set_chan(s58,28);

cout << "\n58\" settings:\n";

s58.settings();

// std::cin.get();

return 0;

}

结果

Initial settings for 42" TV:

TV is Off

Adjusted settings for 42" TV:

TV is On

Volume setting = 5

Channel setting = 3

Mode = cable

Input = TV

42" settings after using remote:

TV is On

Volume setting = 7

Channel setting = 10

Mode = cable

Input = TV

58" settings:

TV is On

Volume setting = 5

Channel setting = 28

Mode = antenna

Input = TV

说明

class Tv{
public:
enum {Off , On};
....
private:
int state;
....
};
void onoff() { state = (state == On)? off : On; }

void onoff() { state = (state == On)? off : On; }
state相当于只取0和1，可用下面代码代替

void onoff() { state^=1;};

^=表示按位异或和赋值
按位异或，表示
与1异或取相反，与0异或不变。（主要是0和1）

友元成员函数

前言

上例中，大多数Remote方法使用Tv类的公有接口实现的。
不是真正需要作为友元的，唯一直接访问Tv成员的Remote
方法是Remote：：set_chan();

作用

让Remote类的set_chan()成为Tv的友元，仅这个函数可以访问
Tv的私有数据成员。

格式

class Tv{
public:
friend void Remote::set_chan( Tv & t , int c );
......
};

说明

声明的过程中还要注意一下两点

/顺序

原因

要编译器能够处理这条语句，它必须知道Remote的定义(类声明)。
否则，它无法知道Remote是一个类，而set_chan是这个类的方法。

Remote的方法提到了Tv对象，意味着应将Remote的定义放到Tv的定义前面。

解决互相依赖的问题，应该使用前向声明。
eg:
class Tv;
class Remote;

正确顺序

class Tv; // forward declaration
class Remote{....};
class Tv{....};

错误顺序

class Remote;
class Tv{....};
class Remote{.....};

原因

编译器在Tv类的声明看到Remote的一个方法被声明为Tv类的
友元之前，应该先看到Remote类的声明和set_chan()方法的声明；

改进

问题

在Remote类中，包含了很多内联代码
void onoff( Tv & t){ t.onoff(); }
t.onoff（）将调用Tv的一个方法，所以编译器此时必须已经看到了Tv类的声明，
这样才能知道Tv有哪些方法，但是Tv的声明在Remote 的后方。

解决

使Remote之包含方法声明，并将实际的定义放在Tv类之后。

排列顺序

class Tv;
class Remote{ ... };
class Tv{ ... };
// put Remote method definitions here;
eg:
inline bool Remote::volup( Tv & t){ return t.voiup;}

注意

内联函数的链接性是内部的，函数的定义必须在使用函数的文件中。（这里是头文件中）
不是内联的函数定义可放在实现文件中，这样函数链接性是外部的。

让整个Romate类成为友元并不需要前向声明，因为友元语句本身已经
指出Remote是一个类。

代码

类声明

// tvfm.h -- Tv and Remote classes using a friend member

#ifndef TVFM_H_

#define TVFM_H_

class Tv; // forward declaration

class Remote

{

public:

enum State{Off, On};

enum {MinVal,MaxVal = 20};

enum {Antenna, Cable};

enum {TV, DVD};

private:

int mode;

public:

Remote(int m = TV) : mode(m) {}

bool volup(Tv & t); // prototype only

bool voldown(Tv & t);

void onoff(Tv & t);

void chanup(Tv & t);

void chandown(Tv & t);

void set_mode(Tv & t);

void set_input(Tv & t);

void set_chan(Tv & t, int c);

};

class Tv

{

public:

friend void Remote::set_chan(Tv & t, int c);

enum State{Off, On};

enum {MinVal,MaxVal = 20};

enum {Antenna, Cable};

enum {TV, DVD};

Tv(int s = Off, int mc = 125) : state(s), volume(5),

maxchannel(mc), channel(2), mode(Cable), input(TV) {}

void onoff() {state = (state == On)? Off : On;}

bool ison() const {return state == On;}

bool volup();

bool voldown();

void chanup();

void chandown();

void set_mode() {mode = (mode == Antenna)? Cable : Antenna;}

void set_input() {input = (input == TV)? DVD : TV;}

void settings() const;

private:

int state;

int volume;

int maxchannel;

int channel;

int mode;

int input;

};

// Remote methods as inline functions

inline bool Remote::volup(Tv & t) { return t.volup();}

inline bool Remote::voldown(Tv & t) { return t.voldown();}

inline void Remote::onoff(Tv & t) { t.onoff(); }

inline void Remote::chanup(Tv & t) {t.chanup();}

inline void Remote::chandown(Tv & t) {t.chandown();}

inline void Remote::set_mode(Tv & t) {t.set_mode();}

inline void Remote::set_input(Tv & t) {t.set_input();}

inline void Remote::set_chan(Tv & t, int c) {t.channel = c;}

#endif

其他友元关系

Remote和Tv互为友元

class Tv
{
friend class Remote;
public:
void buzz( Remote & r);
.....
};

class Remote{
friend class Tv;
public:
void Bool volup(Tv & t) { t.volup();}
};

说明

对于Remote对象的Tv方法，其原型可在Remote类声明之前
声明，但必须在Remote类声明之后定义。

共同的友元

作用

函数成为两个类的友元，可以访问两个类的私有数据。

格式

class Analyzer;
class Probe{
friend void sync( Analyzer &a , const Probe &p);
friend void sync(Probe &p,const Analyzer &a);
....
};

class Anlyzer{
friend void sync( Analyzer &a , const Probe &p);
friend void sync(Probe &p,const Analyzer &a);
};

inline void sync(Analyzer &a , const Probe &p)
{
}
inline void sync( Probe &p,const Analyzer &a )
{
}

没有限定域

嵌套类

作用

帮助实现另一个类，并避免名称冲突

格式

类声明

class Queue

{

private:

.....

class Node

{

public:

Item item;

Node * next;

Node(const Item & i):item(i), next(0){ } //内联实现

};

Node * front; // pointer to front of Queue

Node * rear; // pointer to rear of Queue
......
}

如果想在方法文件中
定义Node（嵌套类）
构造函数

Queue::Node::Node( const Item & i ) :item( i ),next( 0 ) { }

Queue类中函数对
Node对象的创建

bool Queue::enqueue(const Item & item)

{
......

Node * add = new Node(item); // create node
......

}

说明

对类进行嵌套不创建类成员，而定义一种类型。
在Queue类中创建Node对象才创建类成员

嵌套类和访问权限

作用域

含义

嵌套类的声明位置，即Node在Queue的
私有部分/公有部分/保护部分声明

嵌套位置
//下见表，更清晰

嵌套类在另一个类的私有
部分声明

eg：Queue和Node，只有Queue中的成员可以使用Node对象
和指向Node对象的指针

嵌套类在另一个类的保护
部分声明

上+
Queue的派生类可以使用

嵌套类在另一个类的公有
部分声明

上+
外部世界可见

在外部世界使用它格式

class Team{
public:
class Coach{ ... };
};

....

Team::Coach forhire;

说明

嵌套结构和枚举的作用域与此相同

嵌套类、结构和枚举的作用域特征

声明位置	包含它的类是否可以使用它	从包含它的类派生而来的类是否可以使用它	在外部是否可以使用
私有部分	是	否	否
保护部分	是	是	否
公有部分	是	是	是

访问控制

含义

嵌套类的公有部分、私有部分、保护部分控制了
对类成员的访问。

访问控制

访问控制规则和常规类相同

说明

因此Queue类智能访问Node的公有部分，这样有悖于数据成员
声明为私有的惯例，但Node类时Queue类内部实现的一项特性，
对外部世界不可见。

模板中的嵌套

代码

类声明

// queuetp.h -- queue template with a nested class

#ifndef QUEUETP_H_

#define QUEUETP_H_

template <class Item>

class QueueTP

{

private:

enum {Q_SIZE = 10};

// Node is a nested class definition

class Node

{

public:

Item item;

Node * next;

Node(const Item & i):item(i), next(0){ }

};

Node * front; // pointer to front of Queue

Node * rear; // pointer to rear of Queue

int items; // current number of items in Queue

const int qsize; // maximum number of items in Queue

QueueTP(const QueueTP & q) : qsize(0) {}

QueueTP & operator=(const QueueTP & q) { return *this; }

public:

QueueTP(int qs = Q_SIZE);

~QueueTP();

bool isempty() const

{

return items == 0;

}

bool isfull() const

{

return items == qsize;

}

int queuecount() const

{

return items;

}

bool enqueue(const Item &item); // add item to end

bool dequeue(Item &item); // remove item from front

};

// QueueTP methods

template <class Item>

QueueTP<Item>::QueueTP(int qs) : qsize(qs)

{

front = rear = 0;

items = 0;

}

template <class Item>

QueueTP<Item>::~QueueTP()

{

Node * temp;

while (front != 0) // while queue is not yet empty

{

temp = front; // save address of front item

front = front->next;// reset pointer to next item

delete temp; // delete former front

}

// Add item to queue

template <class Item>

bool QueueTP<Item>::enqueue(const Item & item)

{

if (isfull())

return false;

Node * add = new Node(item); // create node

// on failure, new throws std::bad_alloc exception

items++;

if (front == 0) // if queue is empty,

front = add; // place item at front

else

rear->next = add; // else place at rear

rear = add; // have rear point to new node

return true;

}

// Place front item into item variable and remove from queue

template <class Item>

bool QueueTP<Item>::dequeue(Item & item)

{

if (front == 0)

return false;

item = front->item; // set item to first item in queue

items--;

Node * temp = front; // save location of first item

front = front->next; // reset front to next item

delete temp; // delete former first item

if (items == 0)

rear = 0;

return true;

}

#endif

使用

#include <iostream>

#include <string>

#include "queuetp.h"

int main()

{

using std::string;

using std::cin;

using std::cout;

QueueTP<string> cs(5);

string temp;

while(!cs.isfull())

{

cout << "Please enter your name. You will be "

"served in the order of arrival.\n"

"name: ";

getline(cin, temp);

cs.enqueue(temp);

}

cout << "The queue is full. Processing begins!\n";

while (!cs.isempty())

{

cs.dequeue(temp);

cout << "Now processing " << temp << "...\n";

}

// cin.get();

return 0;

}

结果