C++编程语言——基础设施:第8章——结构,合并和枚举(Bjarne Stroustrup)

Matlab:合并结构体 当需要将多个结构体合并成一个大的结构体时,可以使用串联操作。本文将介绍如何使用串联操作将多个结构体合并为一个。对于相同的字段,s3 中的值是一个数组,包含了 s1 和 s2 对应字段的值。本文介绍了如何使用串联操作将多个同类型的结构体合并为一个大的结构体。这里使用了方括号将 s1 和 s2 串联起来,得到一个新的结构体 s3。需要注意的是,串联操作只能用于同类型的结构体。如果需要合并不同类型的结构体,可以使用结构体数组和循环等方法进行处理。现在我们要将这两个结构体合并为一个新的结构体 s3。 阅读详情

第 8 章   结构,合并和枚举

(Structures, Unions, and Enumerations)

目录

8.1  引言

8.2  结构体

8.2.1  结构体的内存布局(struct Layout)

8.2.2  struct 命名(struct Names)

8.2.3  结构体和类(Structures and Classes)

8.2.4  结构体和数组(Structures and Arrays)

8.2.5  类型等价(Type Equivalence)

8.2.6  平坦型旧数据(Plain Old Data)

8.2.7  位域(Fields)

8.3  合并体(Unions)

8.3.1  合并体和类(Unions and Classes)

8.3.2  匿名合并体(Anonymous Unions)

8.4  枚举(Enumerations)

8.4.1  枚举类(Enum Classes)

8.4.2  普通枚举(Plain enums)

8.4.3  无名枚举(Unnamed enums)

8.5  建议


8.1  引言

    有效使用 C++ 的关键是定义和使用用户定义类型。本章介绍用户定义类型概念的三种最原始的变体:

\bullet    struct(结构体)是任意类型的元素(称为成员)序列。

\bullet    union(合并体)是一种在任何时候都只保存其中一个元素值的结构(译注:由于其特征更像是合并,因为我译为合并,其大小是最大的那个类型的大小,这个特点跟集合论中的并集有相似之处)。

\bullet    enum(枚举)是一种具有一组命名常量(称为枚举器)的类型。

\bullet    enum 类(enum class)(作用域枚举)是一种枚举,其中枚举器在枚举作用域内,并且不提供到其他类型的隐式转换(译注:和Java语言中的枚举类相似,语言之间的优点相互借签)。

这些简单类型的变体自 C++ 诞生之初就已存在(译注:作用域枚举,即enum 类是C++ 11新增)。它们主要侧重于数据的表示,是大多数 C 风格编程的支柱。此处描述的结构体概念是类的一种简单形式(§3.2,第 16 章)。

8.2  结构体

数组是同类元素的聚合。结构体以其最简单的形式聚合任意类型的元素。例如:

struct Address {

const char∗ name; // "Jim Dandy"

int number; // 61

const char∗ street; // "South St"

const char∗ town; //"New Providence"

char state[2]; // 'N' 'J'

const char∗ zip; //"07974"

};

这定义了一个名为 Address 的类型,其中包含向美国境内某人发送邮件所需的项目。请注意结尾的分号(“;”)。

    Address 类型的变量可以像其他变量一样声明,并且可以使用 • (点)运算符访问各个成员。例如:

void f()

{

Address jd;

jd.name = "Jim Dandy";

jd.number = 61;

}

结构体类型的变量可以使用 {} 符号初始化(§6.3.5)。例如:

Address jd = {

"Jim Dandy",

61, "South St",

"New Providence",

{'N','J'}, "07974"

};

请注意,jd.state 无法通过字符串“NJ”进行初始化。字符串以零字符“\0”结尾,因此“NJ”有三个字符——比 jd.state 中能容纳的字符多一个。我故意使用相当底层的类型作为成员来说明如何做到这一点以及它可能导致哪些类型的问题。

    通常使用 ⟶ (结构指针解引用)运算符通过指针访问结构。例如:

void print_addr(Address∗ p)

{

cout << p−>name << '\n'

<< p−>number << ' ' << p−>street << '\n'

<< p−>town << '\n'

<< p−>state[0] << p−>state[1] << ' ' << p−>zip << '\n';

}

当 p 为指针时,p−>m 等同于 (∗p).m。

    或者,可以通过引用传递struct并使用 • (结构成员访问)运算符进行访问:

void print_addr2(const Address& r)

{

cout << r.name << '\n'

<< r.number << ' ' << r.street << '\n'

<< r.town << '\n'

<< r.state[0] << r.state[1] << ' ' << r.zip << '\n';

}

参数传递在第 12.2 节中讨论。

    结构类型的对象可以赋值,可作为函数参数传递以及作为函数结果返回。例如:

Address current;

Address set_current(Address next)

{

address prev = current;

current = next;

return prev;

}

其他可行的操作,如比较(== 和 !=),默认情况下不可用。但是,用户可以定义此类运算符(第 18 章第 3.2.1.1 节)。

8.2.1  结构体的内存布局(struct Layout)

结构体对象按照声明的顺序保存其成员。例如,我们可以将从设备读出的数存储在如下结构体中:

struct Readout {

char hour; // [0:23]

int value;

char seq; // sequence mark ['a':'z']

};

你可以想象 Readout 对象的成员在内存中的布局如下:

成员按声明顺序分配在内存中,因此 hour 的地址一定小于 value 的地址。另请参阅 §8.2.6。

    但是,结构体对象的大小不一定是其成员大小的总和。这是因为许多机器要求将某些类型的对象分配在与架构相关的边界上,或者如果这样做,处理此类对象会更加高效。例如,整数通常分配在字边界上。在这样的机器上,对象必须正确对齐(§6.2.9)。这会导致结构中出现“空洞”(译注:也就是说系统分配的内存的地址一定是对齐要求的整数倍,如果结构体不足这么,空出的部分就称为“空洞”,空洞的内容是随机的)。在具有 4 字节 int 对齐的机器上,Readout 的更现实布局会是:

在这种情况下,与许多机器一样,sizeeof(Readout) 为 12,而不是 6,因为人们天真地认为只需将各个成员的大小简单地相加就可以得到 6。

    您可以通过简单地按大小对成员进行排序(最大的成员排在最前面)来最大限度地减少浪费的空间。例如:

struct Readout {

int value;

char hour; // [0:23]

char seq; // sequence mark ['a':'z']

};

这会给出:

请注意,这仍然会在 Readout 中留下一个 2 字节的“空洞”(未使用的空间),并且 sizeof(Readout)==8。原因是当我们将两个对象放在一起时,例如在 Readout 数组中,我们需要保持对齐。10 个 Readout 对象的数组的大小为 10∗sizeof(Readout)。

通常,最好对成员进行排序以便于阅读,并且只有当确实需要优化时才按大小排序。

使用多个访问说明符(即公共、私有或受保护)可能会影响布局(§20.5)。

8.2.2  struct 命名(struct Names)

    类型的名称所见即可用,而无需完整声明后才可用。例如:

struct Link {

Link∗ previous;

Link∗ successor;

};

但是,在结构的完整声明之前,无法声明结构的新对象。例如:

struct No_good {

No_good member; // 错: 递归定义

};

这是一个错误,因为编译器无法确定 No_good 的大小。为了允许两个(或更多)结构相互引用,我们可以将一个名称声明为结构的名称(译注:即先申请一个结构名,在后面再定义)。例如:

struct List; // struct名声明: List 稍后定义

struct Link {

Link∗ pre;

Link∗ suc;

List∗ member_of;

int data;

};

struct List {

Link∗ head;

};

如果没有 List 的第一个声明,则在 Link 的声明中使用指针类型 List∗ 将会出现语法错误。

    struct的名称可以在定义类型之前使用,只要这种使用不需要知道成员的名称或结构的大小即可。但是,在完成结构声明之前,该结构都是不完整的类型。例如:

struct S; // ‘‘S’’是某种类型名

extern S a;

S f();

void g(S);

S∗ h(S∗);

但是,除非定义了类型 S,否则许多此类声明都不能使用:

void k(S∗ p)

{

S a; // 错 : S 未定义; 分配需知大小

f(); //错 :  S 未定义; 反回值需知大小

g(a); //错 :  S 未定义; 传参需知大小

p−>m = 7; //错 :  S 未定义; 未知成员名

S∗ q = h(p); // ok: 可分配和传递指针

q−>m = 7; //错 :  S 未定义; 成员名未知

}

由于可追溯的 C 语言史前原因,可以在同一作用域内声明具有相同名称的结构和非结构。例如:

  struct stat { /* ... */ };

int stat(char∗ name, struct stat∗ buf);

在这种情况下,普通名称 (stat) 是非结构的名称,并且必须使用前缀 struct 来引用结构。同样,关键字 class、union (§8.3) 和 enum (§8.4) 可用作前缀以消除歧义。但是,最好不要重载名称,以使这种显式歧义成为必要。

8.2.3  结构体和类(Structures and Classes)

结构体只是一个类,其成员默认为公共。因此,结构体可以有成员函数(§2.3.2,第 16 章)。特别是,结构体可以有构造函数。例如:

struct Points {

vector<Point> elem;// 必须至少包含一个Point

Points(Point p0) { elem.push_back(p0);}

Points(Point p0, Point p1) { elem.push_back(p0); elem.push_back(p1); }

// ...

};

Points x0; // 错: 无默认构造函数

Points x1{ {100,200} }; // 1个Point

Points x1{ {100,200}, {300,400} }; // 2个Points

您不需要定义构造函数来按顺序初始化成员。例如:

struct Point {

int x, y;

};

Point p0; // 危险 : 若在局域作用域内未初始化(§6.3.5.1)

Point p1 {}; // 默认构造函数: {{},{}};即 {0.0}

Point p2 {1}; // 第二个成员默认构造: {1,{}}; 即{1,0}

Point p3 {1,2}; // {1,2}

如果需要重新排序参数、验证参数、修改参数、建立不变量(§2.4.3.2、§13.4)等,则需要构造函数。例如:

struct Address {

string name; // "Jim Dandy"

int number; // 61

string street; // "South St"

string town; // "New Providence"

char state[2]; // ’N’ ’J’

char zip[5]; // 07974

Address(const string n, int nu, const string& s, const string& t, const string& st, int z);

};

在这里,我添加了一个构造函数,以确保每个成员都已初始化,并允许我使用字符串和 int 作为邮政编码,而不是摆弄单个字符。例如:

Address jd = {

"Jim Dandy",

61, "South St",

"New Providence",

"NJ", 7974 // (07974 would be octal; §6.2.4.1)

};

Address 构造函数可能定义如下:

Address::Address(const string& n, int nu, const string& s, const string& t, const string& st, int z)

// validate postal code

:name{n},

number{nu},

street{s},

town{t}

{

if (st.size()!=2)

error("State abbreviation should be two characters")

state = {st[0],st[1]}; //将邮政编码存储为字符

ostringstream ost; //输出字符串流;参见 §38.4.2

ost << z; //从 int 中提取字符

string zi {ost.str()};

switch (zi.siz e()) {

case 5:

zip = {zi[0], zi[1], zi[2], zi[3], zi[4]};

break;

case 4: // star ts with ’0’

zip = {'0', zi[0], zi[1], zi[2], zi[3]};

break;

default:

error("unexpected ZIP code format");

}

// ... 检验编码使其有意义 ...

}

8.2.4  结构体和数组(Structures and Arrays)

当然,我们可以有结构体的数组和包含数组的结构体。例如:

struct Point {

int x,y

};

Point points[3] {{1,2},{3,4},{5,6}};

int x2 = points[2].x;

struct Array {

Point elem[3];

};

Array points2 {{1,2},{3,4},{5,6}};

int y2 = points2.elem[2].y;

将内置数组放入结构体中允许我们将该数组视为对象:我们可以在初始化(包括参数传递和函数返回)和赋值时复制包含它的结构体。例如:

Array shift(Array a, Point p)

{

for (int i=0; i!=3; ++i) {

a.elem[i].x += p.x;

a.elem[i].y += p.y;

}

return a;

}

Array ax = shift(points2,{10,20});

Array 的符号有点原始:为什么 i!=3?为什么一直重复 .elem[i]?为什么只是 Point 类型的元素?标准库提供了std::array (§34.2.1),作为固定大小数组作为结构体思想的更完整、更优雅的开发:

template<typename T, siz e_t N >

struct array { // simplified (see §34.2.1)

T elem[N];

T∗ begin() noexcept { return elem; }

const T∗ begin() const noexcept {return elem; }

T∗ end() noexcept { return elem+N; }

const T∗ end() const noexcept { return elem+N; }

constexpr size_t size() noexcept;

T& operator[](size_t n) { return elem[n]; }

const T& operator[](size_type n) const { return elem[n]; }

T ∗ data() noexcept { return elem; }

const T ∗ data() const noexcept { return elem; }

// ...

};

此数组是一个模板,允许任意数量的任意类型的元素。它还直接处理异常(§13.5.1.1)和 const 对象(§16.2.9.1)的可能性。使用array,我们现在可以编写:

struct Point {

int x,y

};

using Array = array<Point,3>; // 3 个 Points 的数组

Array points {{1,2},{3,4},{5,6}};

int x2 = points[2].x;

int y2 = points[2].y;

Array shift(Array a, Point p)

{

for (int i=0; i!=a.size(); ++i) {

a[i].x += p.x;

a[i].y += p.y;

}

return a;

}

Array ax = shift(points,{10,20});

std::array 相对于内置数组的主要优势在于它是一种合适的对象类型(具有赋值等),并且不会隐式转换为指向单个元素的指针:

ostream& operator<<(ostream& os, Point p)

{

cout << '{' << p[i].x << ',' << p[i].y << '}';

}

void print(Point a[],int s) // must specify number of elements

{

for (int i=0; i!=s; ++i)

cout << a[i] << '\n';

}

template<typename T, int N>

void print(array<T,N>& a)

{

for (int i=0; i!=a.size(); ++i)

cout << a[i] << '\n';

}

Point point1[] = {{1,2},{3,4},{5,6}}; // 3 elements

array<Point,3> point2 = {{1,2},{3,4},{5,6}}; // 3 elements

void f()

{

print(point1,4); // 4 is a bad error

print(point2);

}

与内置数组相比,std::array 的缺点是我们无法从初始化器的长度推断出元素的数量:

Point point1[] = {{1,2},{3,4},{5,6}}; // 3 elements

array<Point,3> point2 = {{1,2},{3,4},{5,6}}; // 3 elements

array<Point> point3 = {{1,2},{3,4},{5,6}}; // 错 :未给出元素数

8.2.5  类型等价(Type Equivalence)

    即使两个结构体具有相同的成员(译注:等价类型),它们也是不同的类型。例如:

struct S1 { int a; };

struct S2 { int a; };

S1 和 S2 是两种不同的类型,因此:

S1 x;

S2 y = x; // 错 : 类型不匹配

结构体也是与用作成员的类型不同的类型。例如:

S1 x;

int i = x; //错 : 类型不匹配

每个结构在程序中都必须具有唯一的定义(§15.2.3)。

8.2.6  平坦型旧数据(Plain Old Data)

    有时,我们只想将对象视为“平坦旧数据”(内存中连续的字节序列),而不必担心更高级的语义概念,例如运行时多态性(§3.2.3、§20.3.2)、用户定义的复制语义(§3.3、§17.5)等。通常,这样做的原因是为了能够以硬件能够实现的最高效方式移动对象。例如,使用 100 次复制构造函数调用复制 100 个元素的数组不太可能像调用 std::memcpy()那样快,后者通常只使用块移动机器指令。即使构造函数是内联的,优化器也很难发现这种优化。这种“技巧”并不罕见,而且在容器(如vector)的实现和底层 I/O 例程中很重要。它们是不必要的,应该在高级代码中避免使用。

    因此,POD(“平坦旧数据”)是一种可以作为“纯数据”进行操作的对象,无需担心类布局的复杂性或构造、复制和移动的用户定义语义。例如:

struct S0 { }; // a POD

struct S1 { int a; }; // a POD

struct S2 { int a; S2(int aa) : a(aa) { } }; // not a POD (no default constructor)

struct S3 { int a; S3(int aa) : a(aa) { } S3() {} }; // a POD (user-defined default constructor)

struct S4 { int a; S4(int aa) : a(aa) { } S4() = default; }; // a POD

struct S5 { virtual void f(); /* ... */ }; // not a POD (has a virtual function)

struct S6 : S1 { }; // a POD

struct S7 : S0 { int b; }; // a POD

struct S8 : S1 { int b; }; // not a POD (data in both S1 and S8)

struct S9 : S0, S1 {}; // a POD

为了让我们能够将对象作为“仅仅是数据”(作为 POD)来操作,该对象必须

• 没有复杂的内存布局(例如,使用 vptr;(§3.2.3、§20.3.2),

• 没有非标准(用户定义)复制语义,并且

• 有一个简单的默认构造函数。

显然,我们需要精确定义 POD,以便我们只在不破坏任何语言保证的情况下使用此类优化。正式地(§iso.3.9、§iso.9),POD 对象必须是

• 标准内存布局类型,以及

• 可简单复制的类型,

• 具有简单默认构造函数的类型。

一个相关的概念是平凡类型(trivial type),它是一种具有

• 一个简单的默认构造函数和

• 简单的复制和移动操作

的类型。

    非正式地,如果默认构造函数不需要做任何工作,那么它就是简单的(如果需要定义一个,请使用 = default §17.6.1)。

    类型有标准布局,除非

• 具有非标准布局的非静态成员或基类,

• 具有虚拟函数(§3.2.3、§20.3.2),

• 具有虚拟基类(§21.3.5),

• 具有引用成员(§7.7),

• 具有非静态数据成员的多个访问说明符(§20.5),或

• 阻止重要的布局优化:

(1) 在多个基类中或在派生类和基类中都拥有非静态数据成员,或者

(2) 拥有与第一个非静态数据成员相同类型的基类。

基本上,标准布局类型是一种具有与 C 中明显等价的布局并且属于常见 C++ 应用程序二进制接口 (ABI) 可以处理的合并体的类型。

除非类型具有非平凡的复制操作、移动操作或析构函数(§3.2.1.2、§17.6),否则该类型是可平凡复制的。非正式地说,如果复制操作可以实现为按位复制,则它是平凡的。那么,是什么让复制、移动或析构函数变得非平凡?

• 它是用户定义的。

• 它的类有一个虚拟函数。

• 它的类有一个虚拟基。

• 它的类有一个不平凡的基或成员。

内置类型的对象是可简单复制的,并且具有标准布局。此外,可简单复制的对象数组也是可简单复制的,而标准布局对象的数组具有标准布局。考虑一个例子:

template<typename T>

void mycopy(T∗ to, const T∗ from, int count);

我想优化 T 是 POD 的简单情况。我可以通过只为 POD 调用 mycopy() 来做到这一点,但这很容易出错:如果我使用 mycopy(),我能否依靠代码维护者记住永远不要为非 POD 调用 mycopy()?实际上,我不能。或者,我可以调用 std::copy(),这很可能是通过必要的优化实现的。无论如何,这是通用的和优化的代码:

template<typename T>

void mycopy(T∗ to, const T∗ from, int count)

{

if (is_pod<T>::value)

memcpy(to,from,count∗sizeof(T));

else

for (int i=0; i!=count; ++i)

to[i]=from[i];

}

    is_pod 是 <type_traits> 中定义的标准库类型属性谓词 (§35.4.1),允许我们在代码中提出问题“T 是 POD 吗?”。is_pod<T> 的最大优点是它让我们无需记住 POD 的确切规则。

    请注意,添加或减少非默认构造函数不会影响布局或性能(在 C++98 中并非如此)。

    标准(§iso.3.9、§iso.9)并尝试思考它们对程序员和编译器编写者的影响。这样做可能会在它占用你太多时间之前治愈你的冲动。

8.2.7  位域(Fields)

    使用整个字节(char 或 bool)来表示二进制变量(例如,一个on/off开关)似乎有些奢侈,但 char 是 C++ 中可以独立分配和寻址的最小对象(§7.2)。但是,可以将几个这样的小变量捆绑在一起作为结构中的字段。字段通常称为位域。通过指定成员要占用的位数,将其定义为位域。允许使用未命名的位域。它们不会影响命名位域的含义,但可以以某种与机器相关的方式使用它们来改善布局:

struct PPN { // R6000 物理页号

unsigned int PFN : 22; // 页帧号

int : 3; // 未用

unsigned int CCA : 3; // 缓存一致性算法

bool nonreachable : 1;

bool dirty : 1;

bool valid : 1;

bool global : 1;

};

此示例还说明了字段的其他主要用途:命名外部强加的布局的各个部分。位域必须是整数或枚举类型(§6.2.1)。无法获取位域的地址。除此之外,它可以像其他变量一样使用。请注意,bool 字段实际上可以用单个位表示。在操作系统内核或调试器中,PPN 类型可能按如下方式使用:

void part_of_VM_system(PPN∗ p)

{

// ... if (p−>dirty) { // contents changed

// copy to disk

p−>dirty = 0;

}

}

令人惊讶的是,使用位域将多个变量打包成一个字节并不一定能节省空间。虽然它节省了数据空间,但在大多数机器上,操作这些变量所需的代码大小会增加。众所周知,当二进制变量从位域转换为字符时,程序会大大缩小!此外,访问 char 或 int 通常比访问位域快得多。位域只是使用按位逻辑运算符(§11.1.1)从字的一部分中提取信息和将信息插入其中某位的的一种方便的简写。

8.3  合并体(Unions)

    合并体是一种其中所有成员都分配在同一地址的结构,因此合并仅占用其最大成员的空间。当然,合并体一次只能保存一个成员的值。例如,考虑一个包含名称和值的符号表条目:

enum Type { str, num };

struct Entry {

char∗ name;

Type t;

char∗ s; // use s if t==str

int i; // use i if t==num

};

void f(Entry∗ p)

{

if (p−>t == str)

cout << p−>s;

// ...

}

成员 s 和 i 永远不能同时使用,因此会浪费空间。可以通过指定两者都应为 union 的成员来轻松回收空间,如下所示:

union Value {

char∗ s;

int i;

};

该语言不跟踪联合体保存哪种值,因此程序员必须这样做:

struct Entry {

char∗ name;

Type t;

Value v; // use v.s if t==str; use v.i if t==num

};

void f(Entry∗ p)

{

if (p−>t == str)

cout << p−>v.s;

// ...

}

为了避免错误,可以封装一个union,这样就可以保证类型字段和union成员访问之间的对应关系(§8.3.2)。

    union有时会被误用为“类型转换”。这种误用主要由接受过没有明确类型转换功能的语言培训的程序员实施,因此作弊是必要的。例如,以下代码只需假设按位等价即可将 int 转换为 int∗:

union Fudge {

int i;

int∗ p;

};

int∗ cheat(int i)

{

Fudge a;

a.i = i;

return a.p; // 严重误用

}

这实际上根本不是转换。在某些机器上,int 和 int∗ 占用的空间大小不同,而在其他机器上,没有整数可以有奇数地址。这种合并的使用是危险的,并且不可移植。如果您需要这种本质上丑陋的转换,请使用显式类型转换运算符(§11.5.2),以便读者可以看到发生了什么。例如:

int∗ cheat2(int i)

{

return reinterpret_cast<int∗>(i); // 明显是丑陋且危险的

}

在这里,如果对象的大小不同,编译器至少有机会警告你,并且这样的代码会显得格格不入。

   使用合并体对于数据紧凑性以及性能至关重要。但是,大多数程序使用联合后性能并没有得到太大的改进,而且合并体很容易出错。因此,我认为合并体是一种过度使用的功能;尽可能避免使用它们。

8.3.1  合并体和类(Unions and Classes)

    许多非平凡合并体的成员比最常用的成员大得多。由于合并体的大小至少与其最大成员一样大,因此会浪费空间。通常可以通过使用一组派生类(§3.2.2,第 20 章)代替合并体来消除这种浪费。

    从技术上讲,合并体是一种结构体(struct)(§8.2),而结构体又是一种类(第 16 章)。

但是,为类提供的许多功能与合并体无关,因此对合并体施加了一些限制:

[1] 合并体不能具有虚函数。

[2] 合并体不能具有引用类型的成员。

[3] 合并体不能具有基类。

[4] 如果合并体的成员具有用户定义的构造函数、复制操作、移动操作或析构函数,则该特殊函数将被删除(§3.3.4、§17.6.4);

也就是说,它不能用于合并体类型的对象。

[5] 合并体最多只能有一个成员具有类内初始化程序(§17.4.4)。

[6] 合并体不能用作基类。

    这些限制可以防止许多细微的错误,并简化 union 的实现。后者很重要,因为 union 的使用通常是一种优化,我们不希望强加“隐性成本”来损害这一点。

    从具有构造函数(等)的成员的合并体中删除构造函数(等)的规则使简单合并体保持简单,并迫使程序员在需要时提供复杂的操作。例如,由于 Entry 没有具有构造函数、析构函数或赋值的成员,因此我们可以自由地创建和复制 Entry。例如:

void f(Entry a)

{

Entry b = a;

};

使用更复杂的合并体来执行此操作会导致实施困难或错误:

union U {

int m1;

complex<double> m2; // complex 有一个构造函数

string m3; // string有一个构造函数(保持严格不变)

};

如果要复制 U,我们必须决定使用哪种复制操作。例如:

void f2(U x)

{

U u; // 错 : 调用哪一个默认构造函数?

U u2 = x; //错: 调用哪一个复制构造函数?

u.m1 = 1; // 赋值给int

string s = u.m3; // 灾难 : 从字符串成员读取

return; //错:对于 x, u, 和 u2 调用哪一个析构函数?

}

写入一个成员然后读取另一个成员是违背语法的,但人们还是会这样做(通常是错误的)。在这种情况下,string复制构造函数将被调用并带有无效参数。幸运的是,U 不会编译。在需要时,用户可以定义一个包含合并体的类,该类使用构造函数、析构函数和赋值正确处理合并成员(§8.3.2)。如果需要,这样的类还可以防止写入一个成员然后读取另一个成员的错误。

    最多可以为一个成员指定类内初始化器。如果这样,则此初始化器将用于默认初始化。例如:

union U2 {

int a;

const char∗ p {""};

};

U2 x1; //默认初始化器为 x1.p == ""

8.3.2  匿名合并体(Anonymous Unions)

    要了解如何编写一个能够克服滥用 union 的问题的类,请考虑 Entry 的一个变体(§8.3):

class Entry2 { //两个替代表示形式表示为一个合并体

private:

enum class Tag { number, text };

Tag type; //判别式

union { // 表示

int i;

string s; // string 有默认构造函数、复制操作和析构函数

};

public:

struct Bad_entry { }; // 用作异常

string name;

˜Entry2();

Entry2& operator=(const Entry2&); //由于字符串变体而必需

Entry2(const Entr y2&);

// ...

int number() const;

string text() const;

void set_number(int n);

void set_text(const string&);

// ...

};

我不喜欢 get/set 函数,但在这种情况下,我们确实需要在每次访问时执行一个非平凡的用户指定操作。我选择以值命名“get”函数,并使用 set_ 前缀作为“set”函数。这恰好是我最喜欢的命名约定。

    读访问函数可以定义如下:

int Entry2::number() const

{

if (type!=Tag::number) throw Bad_entry{};

return i;

};

string Entry2::text() const

{

if (type!=Tag::text) throw Bad_entry{};

return s;

};

这些访问函数会检查类型标记,如果标记与我们需要的访问正确对应,则返回对该值的引用;否则,将引发异常。这样的联合通常称为带标记合并体(tagged union)或可区分合并体(discriminated union)。

    写访问函数基本上对类型标签进行相同的检查,但请注意,设置新值时必须考虑先前的值:

void Entry2::set_number(int n)

{

if (type==Tag::text) {

s.˜string(); // 显式销毁 string (§11.2.4)

type = Tag::number;

}

i = n;

}

void Entry2::set_text(const string& ss)

{

if (type==Tag::text)

s = ss;

else {

new(&s) string{ss}; //  定位放置 new: 显式构造 string (§11.2.4)

type = Tag::text;

}

}

使用 union 迫使我们使用其他晦涩难懂的底层语言工具(显式构造和析构)来管理 union 元素的生命周期。这是谨慎使用 union 的另一个原因。

    请注意,Entry2 声明中的合并体未命名。这使它成为一个匿名合并体。匿名合并体是一个对象,而不是类型,并且无需提及对象名称即可访问其成员。这意味着我们可以像使用类的其他成员一样使用匿名合并体的成员——只要我们记住合并体成员实际上一次只能使用一个。

    Entry2 有一个带有用户定义赋值运算符的类型成员,即字符串,因此 Entry2 的赋值运算符被删除(§3.3.4、§17.6.4)。如果我们想赋值Entry2,我们必须定义 Entry2::operator=()。赋值结合了读取和写入的复杂性,但在逻辑上与访问函数类似:

Entry2& Entr y2::operator=(const Entr y2& e) //由于字符串变体而必需

{

if (type==Tag::text && e.type==Tag::text) {

s = e.s; // 常规string 赋值

return ∗this;

}

if (type==Tag::text) s.˜string(); // 显式销毁 (§11.2.4)

switch (e.type) {

case Tag::number:

i = e.i;

break;

case Tag::text:

new(&s)(e .s); // 定位放置new: 显式构造 (§11.2.4)

type = e.type;

}

return ∗this;

}

构造函数和移动赋值可以根据需要以类似的方式定义。我们至少需要一个或两个构造函数来建立类型标记和值之间的对应关系。析构函数必须处理字符串大小写:

Entry2::˜Entry2()

{

if (type==Tag::text) s.˜string(); // 显式销毁 (§11.2.4)

}

8.4  枚举(Enumerations)

枚举是一种可以保存用户指定的一组整数值的类型(§iso.7.2)。枚举的一些可能值被命名并称为枚举项(enumerators)。例如:

enum class Color { red, green, blue };

这定义了一个名为 Color 的枚举,枚举项为red,green和blue。“enumeration”通俗地缩写为“enum”。

    有两种枚举:

[1] 枚举类(enum class),其枚举项名称(例如 red)是枚举的局部名称,并且它们的值不会隐式转换为其他类型。

[2] “普通枚举(Plain enums)”,其枚举项名称与枚举在同一作用域内,并且它们的值隐式转换为整数。

    一般来说,更喜欢枚举类,因为它们引起的意外更少。

8.4.1  枚举类(Enum Classes)

枚举类是具有作用域和强类型的枚举。例如:

enum class Traffic_light { red, yellow, green };

enum class Warning { green, yellow, orange, red }; // fire alert levels

Warning a1 = 7; // 错: 无int到Waning 的转换

int a2 = green; //错: green 不在作用域

int a3 = Warning::green; // //错:无Waning 到int的转换

Warning a4 = Warning::green; // OK

void f(Traffic_light x)

{

if (x == 9) { /* ... */ } // 错: 9不是一个交通信号灯

if (x == red) { /* ... */ } // 错:作用域内没有red

if (x == Warning::red) { /* ... */ } // 错: x 不是Warning

if (x == Traffic_light::red) { /* ... */ } // OK

}

请注意,两个枚举中存在的枚举项不会发生冲突,因为每个枚举项都在其自己的枚举类的作用域内。

    枚举由某个整数类型表示,每个枚举项由某个整数值表示。我们将用于表示枚举的类型称为其基础类型。基础类型必须是有符号或无符号整数类型之一(§6.2.4);默认值为 int。我们可以明确说明:

enum class Warning : int { green, yellow, orange, red }; // sizeof(War ning)==sizeof(int)

如果我们认为这太浪费空间,我们可以使用 char:

enum class Warning : char { green, yellow, orange, red }; // sizeof(War ning)==1

默认情况下,枚举值从 0 开始递增分配。这里,我们得到:

static_cast<int>(Warning::green)==0

static_cast<int>(Warning::yellow)==1

static_cast<int>(Warning::orang e)==2

static_cast<int>(Warning::red)==3

将变量声明为 Warning 而不是普通的 int 可以为用户和编译器提供有关预期用途的提示。例如:

void f(Warning key)

{

switch (key) {

case Warning::green:

// do something

break;

case Warning::orang e:

// do something

break;

case Warning::red:

// do something

break;

}

}

人们可能会注意到缺少了黄色,而编译器可能会发出警告,因为只有四个警告值中的三个被处理。

    枚举项可以通过整数类型(§6.2.1)的常量表达式(§10.4)初始化。例如:

enum class Printer_flags {

acknowledg e=1,

paper_empty=2,

busy=4,

out_of_black=8,

out_of_color=16,

//

};

Printer_flags 枚举项的值经过选择,以便可以通过按位运算进行组合。枚举是用户定义的类型,因此我们可以为其定义 | 和 & 运算符(§3.2.1.1,第 18 章)。例如:

constexpr Printer_flags operator|(Printer_flags a, Printer_flags b)

{

return static_cast<Printer_flags>(static_cast<int>(a))|static_cast<int>(b));

}

constexpr Printer_flags operator&(Printer_flags a, Printer_flags b)

{

return static_cast<Printer_flags>(static_cast<int>(a))&static_cast<int>(b));

}

显式转换是必要的,因为类枚举不支持隐式转换。鉴于 Printer_flags 的 | 和 & 的定义,我们可以这样写:

void try_to_print(Printer_flags x)

{

if (x&Printer_flags::acknowledg e) {

// ...

}

else if (x&Printer_flags::busy) {

// ...

}

else if (x&(Printer_flags::out_of_black|Printer_flags::out_of_color)) {

//要么我们失去了black,要么我们没有彩色

// ...

}

// ...

}

我将 operator|() 和 operator&() 定义为 constexpr 函数(§10.4、§12.1.6),因为有人可能想在常量表达式中使用这些运算符。例如:

void g(Printer_flags x)

{

switch (x) {

case Printer_flags::acknowledge:

// ...

break;

case Printer_flags::busy:

// ...

break;

case Printer_flags::out_of_black:

// ...

break;

case Printer_flags::out_of_color:

// ...

break;

case Printer_flags::out_of_black&Printer_flags::out_of_color:

//我们没有black且没有彩色

// ...

break;

}

// ...

}

可以先声明一个枚举类,而后再定义它(§6.3)。例如:

enum class Color_code : char; // declaration

void foobar(Color_code∗ p); // use of declaration

// ...

enum class Color_code : char { // definition

red, yellow, green, blue

};

整数类型的值可以显式转换为枚举类型。除非该值在枚举的基本类型的范围内,否则这种转换的结果是未定义的。例如:

enum class Flag : char{ x=1, y=2, z=4, e=8 };

Flag f0{}; //f0 gets the default value 0

Flag f1 = 5; // 类型钷: 5不是类型Flag

Flag f2 = Flag{5}; //错: 无到枚举类的窄化㔹换

Flag f3 = static_cast<Flag>(5); //蛮力

Flag f4 = static_cast<Flag>(999); // 错: 999 不是一个char 值(可能不会捕捉到)

最后的任务说明了为什么没有从整数到枚举的隐式转换;大多数整数值在具体的枚举中没有表示。

    每个枚举项都有一个整数值。我们可以显式地提取该值。例如:

int i = static_cast<int>(Flag::y); // i becomes 2

char c = static_cast<char>(Flag::e); // c becomes 8

枚举值范围的概念与 Pascal 语言系列中的枚举概念不同。但是,在 C 和 C++ 中,需要枚举项之外的值进行良好定义的位操作示例(例如 Printer_flags 示例)由来已久。

    枚举类的大小是其基础类型的大小。具体来说,如果没有明确指定基础类型,则大小为 sizeof(int)。

8.4.2  普通枚举(Plain enums)

    “普通枚举”大致就是 C++ 在引入枚举类之前提供的功能,因此您会在许多 C 和 C++98 风格的代码中找到它们。普通枚举的枚举器被导进到枚举的作用域中,并隐式转换为某种整数类型的值。请考虑 §8.4.1 中移除“class”的示例:

enum Traffic_light { red, yellow, green };

enum Warning { green, yellow, orange, red }; // fire alert levels

// 错: yellow 的两个定义(指向定一个值)(译注:两个枚举中的项有重复)

//错: red 的两个定义(指向不同值) (译注:两个枚举中的项有重复)

Warning a1 = 7; //错: 无 int->Warning 转换

int a2 = green; // OK: green is in scope and converts to int

int a3 = Warning::green; // OK: War ning->int conversion

Warning a4 = Warning::green; // OK

void f(Traffic_light x)

{

if (x == 9) { /* ... */ } // OK (but Traffic_light doesn’t have a 9)

if (x == red) { /* ... */ } // 错: 作用域内两个reds

if (x == Warning::red) { /* ... */ } // OK (Ouch!)

if (x == Traffic_light::red) { /* ... */ } // OK

}

我们很幸运,在单个作用域中用两个普通枚举定义红色可以避免难以发现的错误。考虑通过消除枚举器的歧义来“清理”普通枚举(在小程序中很容易做到,但在大程序中很难做到):

enum Traffic_light { tl_red, tl_yellow, tl_green };

enum Warning { green, yellow, orange, red }; // fire alert levels

void f(Traffic_light x)

{

if (x == red) { /* ... */ } // OK (ouch!)

if (x == Warning::red) { /* ... */ } // OK (ouch!)

if (x == Traffic_light::red) { /* ... */ } // 错: red 不是一个Traffic_light 值

}

编译器接受 x==red,这几乎肯定是一个错误。将名称注入封闭作用域(如枚举,但不是枚举类或类)是命名空间污染,并且可能成为大型程序中的一个主要问题(第 14 章)。

    您可以指定普通枚举的底层类型,就像枚举类一样。如果您这样做,则可以声明枚举,而不必稍后再定义它们。例如:

enum Traffic_light : char { tl_red, tl_yellow, tl_green }; // 底层类型是char

enum Color_code : char; // declaration

void foobar(Color_code∗ p); // use of declaration

// ...

enum Color_code : char { red, yellow, green, blue }; // definition

如果不指定底层类型,则无法在不定义枚举的情况下声明枚举,其底层类型由一个相对复杂的算法确定:当所有枚举器都为非负数时,枚举的范围为 [0:2k-1],其中 2k 是所有枚举器都在范围内的 2 的最小幂。如果有负枚举器,则范围为 [-2k:2k-1]。这定义了能够使用常规的二进制补码表示法保存枚举器值的最小位字段。例如:

enum E1 { dark, light }; // range 0:1

enum E2 { a = 3, b = 9 }; // range 0:15

enum E3 { min = −10, max = 1000000 }; // range -1048576:1048575

将整数显式转换为普通枚举的规则与类枚举相同,只是当没有显式基础类型时,这种转换的结果是未定义的,除非值在枚举的范围内。例如:

enum Flag { x=1, y=2, z=4, e=8 }; // range 0:15

Flag f0{}; //f0 取默认值 0

Flag f1 = 5; //类型错: 5 不是类型Flag类型

Flag f2 = Flag{5}; //错: 无从int 到 Flag的隐式转换

Flag f2 = static_cast<Flag>(5); // OK: 5 在Flag的范围内

Flag f3 = static_cast<Flag>(z|e); // OK: 12在Flag的范围内

Flag f4 = static_cast<Flag>(99); // 未定义: 99不在Flag的范围内

因为存在从普通枚举到其基础类型的隐式转换,所以我们不需要定义 | 来使此示例工作:z 和 e 转换为 int,以便可以评估 z|e。枚举的大小是其基础类型的大小。如果没有明确指定基础类型,则它是某种可以容纳其范围且不大于 sizeof(int) 的整数类型,除非枚举器不能表示为 int 或无符号 int。例如,sizeof(e1) 可以是 1 或可能是 4,但在 sizeof(int)==4 的机器上不是 8。

8.4.3  无名枚举(Unnamed enums)

    普通枚举可以不命名。例如:

enum { arrow_up=1, arrow_down, arrow_sideways };

当我们需要的是一组整数常量而不是用于变量的类型时,我们就会使用它。

8.5  建议

[1] 当数据的紧凑性很重要时,将结构数据成员的布局方式设置为:较大的成员在较小的成员之前;§8.2.1。

[2] 使用位域表示硬件强加的数据布局(译注:位操作);§8.2.7。

[3] 不要天真地尝试通过将多个值打包成一个字节来优化内存消耗;§8.2.7。

[4] 使用合并体节省空间(表示替代方案),而不要用于类型转换;§8.3。

[5] 使用枚举来表示命名常量的集合;§8.4。

[6] 优先使用类枚举而不是“普通”枚举,以尽量减少意外;§8.4。

[7] 定义枚举上的操作以确保安全和简单的使用;§8.4.1

内容来源:

<<The C++ Programming Language >> 第4版,作者 Bjarne Stroustrup

从ENVI SARscape到SNAP:手把手教你迁移哨兵1 GRD数据预处理流程(含避坑指南) 本文详细介绍了从ENVI SARscape迁移到SNAP处理哨兵1 GRD数据的全流程,包括工具哲学差异、数据准备注意事项、核心处理流程等效实现及地形校正技巧。特别针对雷达数据预处理中的常见陷阱提供避坑指南,帮助用户高效完成工具迁移并确保结果质量。 阅读详情

相关推荐

Outlook邮件备份全攻略:从导出到导入的完整流程(附常见问题解决)

本文提供了一份详尽的Outlook邮件备份全攻略,涵盖从导出到导入的完整流程。重点解析了经典桌面版Outlook的.pst文件备份方法、进阶的智能筛选备份策略,以及如何通过导入恢复和工具验证确保备份可用。同时,文章还介绍了构建自动化备份体系与异地容灾的最佳实践,并附有常见问题解决方案,帮助用户建立可靠的邮件数据安全防线。

weixin_29248611的博客 901

C语言结构体简介:“结”在一起,“构”成一“体”

我们一般把结构体中的元素称为“成员”,这些成员的定义就和定义普通变量的方法一样。结构体就是拉了一伙“成员”,组成个大家庭,这个大家庭的名字由大括号前的结构体名定义。注意,这种用大括号{}的初始化方式只能在定义变量的同时进行,就和数组的初始化是一样的。因为已经定义了结构体变量,hero与它上面的结构体自然地捆绑在一起,所以这种情况还可以把结构体类型的名字Person省略掉。它传递的是全部成员的值,也就是将实参中成员的值一一赋值给对应的形参成员。结构体中的元素类型不能是结构体本身的类型。

jjmhx的专栏 904

rk3399 hdmi HDCP key烧录

1.key转换 使用 hdcp\ProvisioningTool_20170526\KeyConverterV2.02 目录下的KeyConvertor.exe工具将1.4key进行转换 转换后得到 TX00000001.skf 文件,将 TX00000001.skf 文件烧录到开发板上,烧录方式: 打开文件 hdcp\ProvisioningTool_20170526\ProvisioningTool20170526\ProvisioningTool.exe 选择烧录方式与烧录路...

qq_32645109的博客 3861

结构体 联合体合并使用笔记

在读写DRV8711芯片寄存器的时候,同一个寄存器地址,不同的位代表不同的功能,为了简化操作,相同地址的功能用一个联合体value(uint_16)定义,在联合体内,对不同的位的寄存器进行长度定义,因此,结构体的内存大小等于所有成员变量大小之和,而联合体的内存大小等于最大成员变量的大小。总结: 结构体中每个成员变量都占用一定的存储空间,联合体的所有成员变量共享同一块内存空间。对结构体成员变量的赋值和访问是分别的,而对联合体的成员变量的赋值和访问是相互影响的。

m0_69637421的博客 433

基于YOLOv8的玉米病害监测系统

本研究的主要目标是设计并实现一个基于深度学习的玉米病害识别系统,通过采用YOLOv8算法进行玉米叶片病害的自动化识别。研究首先对玉米病害的种类和特点进行了分析,选择了具有代表性的病害类型,如玉米锈病、灰叶斑病、枯叶病和健康叶片,以构建一个多类别的分类问题。数据集的构建和处理是研究的关键部分,通过数据增强、图像标注等手段确保了数据的多样性和丰富性,从而提高了模型的泛化能力。

yupan__的博客 497

手把手教你用ECharts打造炫酷3D饼图(附完整源码)

本文详细介绍了如何使用ECharts创建炫酷的3D饼图,从环境配置到完整源码实现,涵盖参数解析、视觉优化和交互增强技巧。通过实战案例,帮助开发者快速掌握3D数据可视化技术,提升数据展示效果。

weixin_29031057的博客 281

C语言基础知识之(十):结构体

一、结构体声明 1、结构体声明位置:在main函数上面 声明语法: struct 结构体类型名称{ 数据类型  成员变量名; 数据类型  成员变量名; 数据类型  成员变量名[ ]; …… }; 例:声明描述学生的结构体:学号、姓名、性别、分数 struct student {     int number;     char name[20];     char sex

leleyuan1130的博客 1336

python后端的支付宝小程序用户认证问题(alipay-sdk-python、pycrypto无法安装)

python后端的支付宝小程序用户认证问题(alipay-sdk-python、pycrypto无法安装) 写在前面 事先说明,本人不是大佬,我只是在不断探索的途中找到了解决这个问题的方法,之前在网上搜索的时候没有看到相关文章,所以就来简单讲一下。 正文 借着蚂蚁金服小程序大赛开通了支付宝小程序个人开发者,尝试将一个微信小程序的项目移植到支付宝上,支付宝对于用户唯一id的获取比微信要复杂很多,微信...

weixin_43102379的博客 3644

第8章:structures, unions, and enumerations

这一章主要讲了关于structures,unions,和enumerations的一些知识。structures:1:我们知道数组是相同类型元素的集合,从最简单定义的角度理解,我们可以认为struct是任意类型元素的集合,默认的访问级别是public。2:在内存中,struct成员分配地址的顺序是按照成员声明的顺序分配的,然而struct对象的内存大小并不简单是其成员内存大小的和。为了节省分配的内存

weishenmetlc的博客 771

IEDA激活码失效?教你5分钟快速续期的方法

本文针对IEDA激活码失效问题,提供了一套从快速应急到深度排查的完整解决方案。文章不仅详解了5分钟快速续期与清理缓存等应急方法,更深入剖析了授权机制、离线激活流程,并指导如何构建可持续的授权管理策略,帮助开发者彻底解决激活困扰,确保开发环境稳定。

a0b1c2d3的专栏 276

PX4从放弃到精通(二十一):使用git管理PX4代码

文章目录前言一、设置git密钥二、将代码上传至gitee 前言 Ubuntu 18.04 PX4 1.11.3 由于github有时网速较慢,本文使用gitee。 一、设置git密钥 ssh-keygen -t rsa -C “your_email@youremail.com” your_email@youremail.com为自己注册的gitee账户邮箱.设置路径与密码时,也直接回车不设置,如下图,密钥生成的位置在红框处. 在密钥目录下按Ctrl+H显示隐藏文件,进入.ssh文件夹用gedit打开id

超维空间科技的博客 3480

C++编程语言:基础设施:第15章——源文件和程序(Bjarne Stroustrup)

C++源文件和程序

ComputerInBook的专栏 1327

13、Java 中 MQTT 异步通知与回调的使用及传感器命令处理

本文详细介绍了在 Java 中使用 MQTT 的异步通知与回调机制,并展示了如何通过 Paho Java 客户端处理与传感器交互的命令。文章包含代码示例,讲解了 MQTT 客户端的连接、订阅、消息处理以及模拟传感器数据发布的过程,适用于希望在 Java 应用中实现 MQTT 通信与设备控制的开发者。

eee77的博客 160

C++编程语言:标准库:第44章——兼容性(Bjarne Stroustrup)

C++ 和 C 的兼容性

ComputerInBook的专栏 936

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

C++编程语言:基础设施:第11章——选择运算和类型转换(Bjarne Stroustrup)

C++选择运算和类型转换

ComputerInBook的专栏 1780

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

Bjarne Stroustrup 对C++程序员的忠告

C++之父Bjarne Stroustrup写的《The C++ Programming Language (Special Edition)》中各章后面的忠告。第1章 致读者[1] 在编写程序时,你是在为你针对某个问题的解决方案中的思想建立起一种具体表示。让程序的结构尽可能地直接反映这些思想:    [a] 如果你能把“它”看成一个独立的概念,就把它做成一个类。    [b] 如果你

喂兔子的菜 2197

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

C++编程语言:标准库:第40章——数值(Numerics)(Bjarne Stroustrup)

C++ 数值运算

ComputerInBook的专栏 749

Bjarne Stroustrup 语录

 Bjarne Stroustrup 语录:一、致读者  1. 在编程序时,你是在为你针对某个问题的解决方案中的思想建立起一种具体表示。让程序的结构尽可能地直接反映这些思想:  ★.如果你能把“它”看成一个独立的概念,就把它做成一个类。  ★.如果你能把“它”看成一个独立的实体,就把它做成某个类的一个对象。  ★.如果两个类有共同的界面,将此界面做成一个抽象类。  ★.如果两个

prochsh的专栏 817

c++之父:Bjarne Stroustrup 语录

c++之父:Bjarne Stroustrup 语录(转)摘录自Bjarne Stroustrup 的《The C++ Programming Language》(Special Edition) 一、致读者1.  在编程序时,你是在为你针对某个问题的解决方案中的思想建立起一种具体表示。让程序的结构尽可能地直接反映这些思想:   ★.如果你能把“它”看成一个独立的概念,就把它做成一个类

ismycxp的专栏 652

Bjarne Stroustrup语录[C++经验]

摘录自Bjarne Stroustrup 的《The C++ Programming Language》(Special Edition) 一、致读者1.在编程序时,你是在为你针对某个问题的解决方案中的思想建立起一种具体表示。让程序的结构尽可能地直接反映这些思想:★.如果你能把“它”看成一个独立的概念,就把它做成一个类。★.如果你能把“它”看成一个独立的实体,就把它做成某...

weixin_30216561的博客 148

C++之父Bjarne Stroustrup对C++使用者的忠告

C++之父Bjarne Stroustrup对C++使用者的忠告 《 http://www.2cto.com/kf/ware/c/2.html 》   C++之父Bjarne Stroustrup 写的The C++ Programming Language (Special Edition) 中各章后 面的忠告。       第1 章致读者 [1] 在编写程序时,你是在为你

Seaeast_Ni的专栏 547

Bjarne Stroustrup对C++程序员的忠告

转自:http://blog.youkuaiyun.com/adm_qxx/archive/2007/05/20/1617488.aspx 第1章 致读者 [1] 在编写程序时,你是在为你针对某个问题的解决方案中的思想建立起一种具体表示。让程序的结构尽可能地直接反映这些思想: [a] 如果你能把“它”看成一个独立的概念,就把它做成一个类。 [b] 如果你能把“它”看成一个独立地实

楚兴 1137
上一篇: C++编程语言——基础设施:第7章——指针,数组和引用(Bjarne Stroustrup)
下一篇: C++编程语言:基础设施:第9章——语句(statements)(Bjarne Stroustrup)
ComputerInBook
博客等级 码龄19年 1168粉丝 465原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值