第5章课后练习
约 3294 字大约 11 分钟
2026-11-10
习题5-01 P187
什么叫做作用域?有哪几种类型的作用域?
作用域是一个标识符在程序正文中有效的区域
作用域类型
- 函数原型作用域:最小的作用域
- 局部作用域:{}
- 类作用域
- 文件作用域
- 命名空间作用域
- 限定作用域的enum枚举类
习题5-02 P187
什么叫做可见性?可见性的一般规则是什么?
- 标识符的有效范围就是标识符的可见性
作用域可见性的一般规则
- 有了才能用:标识符要声明在前,引用在后
- 一山不容二虎:在同一作用域中,不能声明同名的标识符
- 平行宇宙:在没有互相包含关系的不同的作用域中声明的同名标识符,互不影响
- 强龙不压地头蛇:如果在两个或多个具有包含关系的作用域中声明了同名的标识符,则外层标识符在内层不可见
习题5-03 P187
源文件:exercise_5_03.cpp
/*
习题5-03 P187
程序的运行结果是什么?
*/
#include <iostream>
using namespace std;
int x = 5, y = 7;
void myFunction()
{
int y = 10;
cout << "x from myFunction: " << x << "\n";
cout << "y from myFunction: " << y << "\n\n";
}
int main()
{
cout << "x from main: " << x << "\n";
cout << "y from main: " << y << "\n\n";
myFunction();
cout<<"Back from myFunction!\n\n";
cout << "x from main: " << x << "\n";
cout << "y from main: " << y << "\n\n";
return 0;
}习题5-04 P188
源文件:exercise_5_04.cpp
/*
习题5-04 P188
假设有两个无关的类Engine和Fuel,使用时,怎样允许Fuel成员访问Engine中的私有和保护成员
答:将Fuel类声明为Engine类的友元
*/
#include <iostream>
using namespace std;
class Engine
{
friend class Fuel;
private:
int a = 100;
protected:
int b = 200;
};
class Fuel
{
private:
Engine E;
public:
void show() { cout << "a=" << E.a << " b=" << E.b << endl; }
};
int main()
{
Fuel F;
F.show();
system("pause");
return 0;
}习题5-05 P188
什么叫做静态数据成员?它有何特点?
- 静态数据成员是被某个类所有对象共享的数据成员,它不依赖于某个数据成员而存在。
特点:
- 在类内声明,在类外定义,值可以改变(const static不行)
- 只能在类外初始化(const static可以在类内初始化)
- 可通过类名或对象名访问
- 可以用作类成员函数的默认形参
习题5-06 P188
什么叫做静态成员?它有何特点?
- 静态函数成员是被某个类所有对象共享的函数成员,它不依赖于某个数据成员而存在。
特点:
- 可以通过类名或对象名来调用
- 可以直接访问该类的静态数据和函数成员(访问非静态成员必须通过对象名)
- 不依赖于任何对象,直接访问静态数据!(普通函数成员也可访问静态数据成员,但需要借助对象,因为对普通成员函数的调用必须通过对象名)
习题5-07 P188
源文件:exercise_5_07.cpp
/*
习题5-07 P188
定义一个Cat类,拥有静态数据成员numOfCats,记录Cat的个体数目;
静态成员函数getNumOfCats(),读取numOfCats。
设计程序测试这个类,体会静态数据成员和静态成员函数的用法。
*/
#include <iostream>
using namespace std;
// Cat类
class Cat
{
private:
static int numOfCats;
public:
Cat() { numOfCats++; } //构造函数
Cat(Cat &c) { numOfCats++; } //复制构造函数
~Cat() { numOfCats--; } //析构函数
static void getNumOfCats()
{
cout << "numOfCats=" << numOfCats << endl;
}
};
int Cat::numOfCats = 0;
int main()
{
Cat c1, c2;
Cat::getNumOfCats(); // 2个Cat对象
for (int i = 0; i < 5; i++)
{ // 定义的Cat对象在每层循环的末尾都会湮灭,所以每次输出的numOfCats都不变
Cat cc;
Cat::getNumOfCats();
}
Cat c3, c4, c5;
Cat::getNumOfCats(); // 3个Cat对象
system("pause");
return 0;
}习题5-08 P188
什么叫做友元函数?什么叫做友元类?
- 友元函数是在类中用关键字friend修饰的非成员函数(注意它不是类的成员函数)
- 若A类是B的友元类,则A的所有成员函数都是B类的友元函数,都可以访问B类的私有和保护成员
友元类注意点
- 友元类不能传递。A是B的友元,B是C的友元,但A不是C的友元
- 友元关系是单向的。A是B的友元,不能推出B是A的友元
- 友元关系不被继承。B是A的友元,B的派生类不会自动成为A的友元
习题5-09 P188
如果类A是类B的友元,类B是类C的友元,类D是类A的派生类,那么类B是类A的友元吗?类C是类A的友元吗?类D是类B的友元吗?
友元类注意点
- 友元类不能传递。A是B的友元,B是C的友元,但A不是C的友元
- 友元关系是单向的。A是B的友元,不能推出B是A的友元
- 友元关系不被继承。B是A的友元,B的派生类不会自动成为A的友元
答案:
- 根据第二条,不是(不能推出)
- 根据第一条,不是(不能推出)
- 根据第三条,不是(不能推出)
习题5-10 P188
源文件:exercise_5_10.cpp
/*
习题5-10 P188
静态成员变量可以为私有的吗?声明一个私有的静态整型成员变量
答:可以
*/
#include <iostream>
using namespace std;
class A
{
public:
A() { count++; }
~A() { count--; }
//通过静态成员函数访问静态数据成员,如此可不依赖对象,而是通过类名访问静态数据成员
static void showCount()
{
cout << "A::count=" << count << endl;
}
private:
static int count; //私有静态数据成员
};
int A::count = 0; //私有静态数据成员初始化
int main()
{
A::showCount();
A a[10];
A::showCount();
A b[10];
A::showCount();
system("pause");
return 0;
}5-11 P188 在一个文件中定义一个全局变量n,主函数main(),在另一个文件中定义函数fn1(),
源文件:exercise_5_11\exercises_5_11.cpp
/*
5-11 P188
在一个文件中定义一个全局变量n,主函数main(),在另一个文件中定义函数fn1(),
在main()中对n赋值,再调用fn1(),在fn1()中也对n赋值,显示n最后的值。
#简单多文件编译链接过程:
#安装mingw后,在VSCode的TERMINAL输入命令:
#先到这三个文件所在的文件夹
cd chapt5
cd chapt5_exercises
cd exercise_5_11
#编译链接
g++ -g .\exercises_5_11.cpp .\file_5_11.cpp -o exercises_5_11.exe
#此时文件夹中就会有exercises_5_11.exe文件,输入指令执行:
.\exercises_5_11.exe
*/
#include "file_5_11.h"
#include <iostream>
using namespace std;
int n;
int main()
{
n = 1; //对n赋值
cout << "n=" << n << endl;
fn1(); //再次对n赋值
cout << "n=" << n << endl;
return 0;
}exercise_5_11\file_5_11.cpp
源文件:exercise_5_11\file_5_11.cpp
#include"file_5_11.h"
extern int n;
void fn1()
{
n=20;
}exercise_5_11\file_5_11.h
源文件:exercise_5_11\file_5_11.h
#ifndef __FILE_5_11__
#define __FILE_5_11__
void fn1();
#endif5-12 P188 在函数fn1()中定义一个静态变量n,fn1()中对n的值加1,在主函数中调用fn1()10次,显示n的值。
源文件:exercise_5_12\exercises_5_12.cpp
/*
5-12 P188
在函数fn1()中定义一个静态变量n,fn1()中对n的值加1,在主函数中调用fn1()10次,显示n的值。
#简单多文件编译链接过程:
#安装mingw后,在VSCode的TERMINAL输入命令:
#先到这三个文件所在的文件夹
cd chapt5
cd chapt5_exercises
cd exercise_5_12
#编译链接
g++ -g .\exercises_5_12.cpp .\file_5_12.cpp -o exercises_5_12.exe
#此时文件夹中就会有exercises_5_12.exe文件,输入指令执行:
.\exercises_5_12.exe
*/
#include "file_5_12.h"
#include <iostream>
using namespace std;
extern int n;
int main()
{
for (int i = 0; i < 10; i++)
fn1(); // n自增1,输出n的值
return 0;
}exercise_5_12\file_5_12.cpp
源文件:exercise_5_12\file_5_12.cpp
#include "file_5_12.h"
#include <iostream>
void fn1()
{
static int n = 0;
n++; // n自增1
std::cout << "n=" << n << "\n"; //输出n的值
}exercise_5_12\file_5_12.h
源文件:exercise_5_12\file_5_12.h
#ifndef __FILE_5_12__
#define __FILE_5_12__
void fn1();
#endif习题5-13 P188
源文件:exercise_5_13\exercises_5_13.cpp
/*
习题5-13 P188
定义类X、Y、Z,
函数h(X*),满足:类X有私有成员i,
Y的成员函数g(X*)是X的友元函数,实现对X的成员i加1;
类Z是类X的友元类,其成员函数f(X*)实现对X的成员i加5;
函数h(X*)是X的友元函数,实现对X的成员i加10.
在一个文件中定义和实现类,在另一个文件中实现main()函数
#简单多文件编译链接过程:
#安装mingw后,在VSCode的TERMINAL输入命令:
#先到这三个文件所在的文件夹
cd chapt5
cd chapt5_exercises
cd exercise_5_13
#编译链接
g++ -g .\exercises_5_13.cpp .\file_5_13.cpp -o exercises_5_13.exe
#此时文件夹中就会有exercises_5_13.exe文件,输入指令执行:
.\exercises_5_13.exe
*/
#include "file_5_13.h"
#include <iostream>
using namespace std;
extern int n;
int main()
{
X x;
Z z;
x.showi(); //显示对象x中i的值
Y::g(&x); // i增1(Y中静态成员函数可通过类名访问)
x.showi(); //显示对象x中i的值
z.f(&x); // i增5(z中普通成员函数只能通过对象访问)
x.showi(); //显示对象x中i的值
h(&x); // i增10
x.showi(); //显示对象x中i的值
return 0;
}exercise_5_13\file_5_13.cpp
源文件:exercise_5_13\file_5_13.cpp
#include "file_5_13.h"
#include <iostream>
void Y::g(X *x)
{
x->i++;
}
void Z::f(X *x)
{
x->i += 5;
}
void X::showi()
{
std::cout << "i=" << i << "\n";
}
void h(X *x)
{
x->i += 10;
}exercise_5_13\file_5_13.h
源文件:exercise_5_13\file_5_13.h
#ifndef __FILE_5_13__
#define __FILE_5_13__
/*
习题5-13 P188
定义类X、Y、Z,
函数h(X*),满足:类X有私有成员i,
Y的成员函数g(X*)是X的友元函数,实现对X的成员i加1;
类Z是类X的友元类,其成员函数f(X*)实现对X的成员i加5;
函数h(X*)是X的友元函数,实现对X的成员i加10.
在一个文件中定义和实现类,在另一个文件中实现main()函数*/
class X;
class Y
{
public:
static void g(X *x); // Y的成员函数g(X*)是X的友元函数,实现对X的成员i加1;
};
class Z
{
public:
void f(X *x); //类Z是类X的友元类,其成员函数f(X *) 实现对X的成员i加5;
};
class X
{
friend void Y::g(X *x);
friend class Z;
friend void h(X *x);
public:
X() : i(0) {} //构造函数
void showi();
private:
int i;
};
void h(X *x); //函数h(X*)是X的友元函数,实现对X的成员i加10.
#endif习题5-14 P188
源文件:exercise_5_14.cpp
/*
习题5-14 P188
定义Boat与Car两个类,二者都有weight属性,定义一个二者的友元函数getTotalWeight(),计算二者的重量和
*/
#include <iostream>
using namespace std;
class Car;
class Boat
{
friend int getTotalWeight(Boat b, Car c);
public:
Boat(int w) : weight(w) {}
private:
int weight;
};
class Car
{
friend int getTotalWeight(Boat b, Car c);
public:
Car(int w) : weight(w) {}
private:
int weight;
};
//计算二者的重量和
int getTotalWeight(Boat b, Car c)
{
return b.weight + c.weight;
}
int main()
{
Car c(12);
Boat b(98);
cout << "sum of weight = " << getTotalWeight(b, c) << endl;
system("pause");
return 0;
}习题5-15 P188
在函数内部定义的普通局部变量和静态局部变量在功能上有何不同?计算机底层对这两类变量做了怎样不同的处理,导致了这种差异?
- 普通局部变量依赖于对象,对象产生则它产生,对象消失则它消失
- 静态局部变量不依赖于对象,依赖于类,它被类的所有对象共享
- 普通局部变量的存储空间是动态分配的,与对象共存亡。而静态局部变量的存储空间是静态的,直到程序结束才被释放。
习题5-16 P188
编译和连接两个步骤的输入和输出分别是什么类型的文件?两个步骤的任务有什么不同?
在以下几种情况下,在对程序进行编译、连接时是否会报错?会在哪个步骤报错?
(1)定义了一个函数void f(int x,int y),以f(1)的形式调用
(2)在源文件起始处声明了一个函数void f(int x),但未给出其定义,以f(1)的形式调用
(3)在源文件起始处声明了一个函数void f(int x),但未给出其定义,也未对其进行调用
(4)在源文件a.cpp中定义了一个函数void f(int x),在源文件b.cpp中也定义了一个函数void f(int x),试图将两源文件编译后连接在一起
答:
- 编译输出.obj文件,连接输出.exe文件(Windows下)
- 编译输出.o文件,连接输出.out文件(Linux下)
- 编译操作分别对源文件进行处理,生成目标文件,目标文件分为代码段和数据段(包含初始化的数据段和未初始化的数据段)
- 连接操作将不同编译单元的代码段和两类数据段分别合并到一起
- 编译时报错,传入函数f的参数太少,改:f(1,2)
- 连接时报错,调用未定义的函数,改:写出函数定义
- 编译连接不会出错
- 连接时报错,函数被重复定义,改:去掉一个定义
