没有合适的资源?快使用搜索试试~ 我知道了~
首页ANSI/ISO C++专业程序员手册简介
ANSI/ISO C++专业程序员手册简介
需积分: 10 1 下载量 134 浏览量
更新于2024-07-28
收藏 1.01MB PDF 举报
"ANSI/ISO C++ Professional Programmer's Handbook 是一本专注于C++编程语言的专业指南,旨在帮助程序员理解和掌握ANSI/ISO标准的C++语言。本书覆盖了C++的起源、ANSI委员会的建立、C++与其他面向对象语言的区别,并针对不同读者群体进行了详细划分。书中深入探讨了标准的内容,包括新增的条款、术语定义、过时特性等。此外,还重点讲解了操作符重载、特殊成员函数(如默认构造函数、拷贝构造函数、析构函数和赋值运算符)以及相关的编程实践和规则。"
该手册首先介绍了C++的历史,指出ANSI(美国国家标准协会)设立了一个专门的委员会来标准化C++语言。C++作为一门与其它面向对象语言(例如Java或C#)有所区别的语言,其标准制定过程和特点值得深入学习。书中的目标读者定位为专业的C++程序员,内容结构清晰,便于读者按需查阅。
在操作符重载章节,书中详细阐述了如何根据规则适当使用操作符重载,包括限制条件、转换运算符、前缀和后缀操作符的处理,以及如何保持操作符使用的连贯性。同时,讲解了返回对象值的情况以及多态操作符重载的实现,如用户自定义类型的重载和下标运算符的重载。此外,还引入了函数对象的概念,这是C++中实现策略模式和仿函数的重要工具。
关于特殊成员函数,本书详细讨论了默认构造函数的作用,它是如何在没有显式构造函数时自动创建对象;拷贝构造函数用于复制对象,确保数据的正确复制;析构函数则在对象生命周期结束时释放资源;而赋值运算符(又称拷贝赋值)是C++中需要特别关注的,因为它涉及到对象的深拷贝和浅拷贝问题,避免可能导致的引用计数错误和内存泄漏。
通过阅读这本手册,读者将能更全面地理解C++标准,掌握操作符重载和特殊成员函数的使用技巧,从而编写出更加高效、安全的C++代码。对于任何希望提升C++编程技能的专业人士来说,这是一份不可多得的参考资料。
Templates❍
The Standard Template Library❍
Internationalization and Localization❍
Miscellaneous❍
Deprecated Feature
Use of an Operand of Type bool with the Postfix ++ Operator❍
Use of static to Declare Objects in Namespace Scope❍
Access Declarations❍
Implicit Conversion from const to non-const Qualification for String Literals❍
Standard C Headers in the form <name.h>❍
Implicit int Declarations❍
Other Deprecated Features❍
●
Conclusions●
Introduction
C++ today is very different from what it was in 1983, when it was first named "C++". Many features have been added
to the language since then; older features have been modified, and a few features have been deprecated or removed
entirely from the language. Some of the extensions have radically changed programming styles and concepts. For
example, downcasting a base to a derived object was considered a bad and unsafe programming practice before the
standardization of Runtime Type Information. Today, downcasts are safe, and sometimes even unavoidable. The list
of extensions includes const member functions, exception handling, templates, new cast operators, namespaces, the
Standard Template Library, bool type, and many more. These have made C++ the powerful and robust multipurpose
programming language that it is today.
The evolution of C++ has been a continuous and progressive process, rather than a series of brusque revolutions.
Programmers who learned C++ only three or five years ago and haven't caught up with the extensions often discover
that the language slips through their fingers: Existing pieces of code do not compile anymore, others compile with a
plethora of compiler warnings, and the source code listings in object-oriented magazines seem substantially different
from the way they looked not so long ago. "Namespaces? never heard of these before," and "What was wrong with
C-style cast? Why shouldn't I use it anymore?" are some of the frequently asked questions in various C++ forums and
conferences.
Understanding the ANSI/ISO Standard
But even experienced C++ programmers who have kept up with changes by subscribing to newsgroups, reading
magazines and books, or exchanging emails with the company's guru might still find that the C++ nomenclature in
professional literature is sometimes unclear. The ANSI/ISO Standard is written in a succinct and technical jargon that
is jocularly called standardese -- which is anything but plain English. For instance, the One Definition Rule (article
3.2 in the Standard), which defines under what conditions separate definitions of the same entity are valid, is
explained in textbooks in a simpler -- although sometimes less accurate -- manner, when compared to the Standard
text. The use of standardese ensures the accuracy that is needed for writing compilers and checking the validity of
programs. For this purpose, the Standard defines numerous specific terms that are used extensively throughout the
volume; for instance, it distinguishes between a template id and a template name, whereas an average programmer
simply refers to both as templates. Familiarity with these specific terms is the key to reading and interpreting the
ANSI/ISO C++ Professional Programmer's Handbook - Chapter 2 - Standard Briefing: The Latest Addenda to ANSI/ISO C++
file:///D|/Cool Stuff/old/ftp/1/1/ch02/ch02.htm (2 von 24) [12.05.2000 14:45:45]
Standard correctly.
Purpose and Structure of This Chapter
The purposes of this chapter are threefold. First, it presents some of the key terms that are used extensively
throughout the Standard and throughout this book, for example, undefined behavior and deprecated features. (Note
that topic-specific terms such as argument-dependent lookup and trivial constructor are presented in their relevant
chapters rather than here.) Then, the new features that have been added to C++ -- such as bool type, new typecast
operators, and mutable data members -- are discussed. Because these topics are not explained elsewhere in this
book, they are presented here in detail, along with code samples. After that comes a list of other newly added features
that are covered extensively in other chapters of the book.
These topics are presented here only briefly. The intent is to provide you with an executive summary -- a panorama of
the latest addenda to the ANSI/ISO C++ Standard -- that you can use as a checklist of topics. When reading the brief
topics overview, you might come across an unfamiliar topic; in these instances, you are always referred to the chapter
that discusses the topic in further detail. Finally, there is an overview the deprecated features and a list of suggested
replacements for them.
The Standard's Terminology
This part explains some of the key terms in the Standard that are used throughout the book. These terms appear in
italics when they are presented for the first time. Note that these definitions are not exact quotations from the
Standard; rather, they are interpretive definitions.
Arguments and Parameters
The words arguments and parameters are often used interchangeably in the literature, although the Standard makes a
clear distinction between the two. The distinction is chiefly important when discussing functions and templates.
Argument
An argument is one of the following: an expression in the comma-separated list that is bound by the parentheses in a
function call; a sequence of one or more preprocessor tokens in the comma-separated list that is bound by the
parentheses in a function-like macro invocation; the operand of a throw-statement or an expression, type, or
template-name in the comma-separated list that is bound by the angle brackets in a template instantiation. An
argument is also called an actual parameter.
Parameter
A parameter is one of the following: an object or reference that is declared in a function declaration or definition (or
in the catch clause of an exception handler); an identifier from the comma-separated list that is bound by the
parentheses immediately following the macro name in a definition of a function-like macro; or a template-parameter.
A parameter is also called a formal parameter.
The following example demonstrates the difference between a parameter and an argument:
void func(int n, char * pc); //n and pc are parameters
template <class T> class A {}; //T is a a parameter
int main()
{
char c;
ANSI/ISO C++ Professional Programmer's Handbook - Chapter 2 - Standard Briefing: The Latest Addenda to ANSI/ISO C++
file:///D|/Cool Stuff/old/ftp/1/1/ch02/ch02.htm (3 von 24) [12.05.2000 14:45:45]
char *p = &c;
func(5, p); //5 and p are arguments
A<long> a; //'long' is an argument
A<char> another_a; //'char' is an argument
return 0;
}
Translation Unit
A translation unit contains a sequence of one or more declarations. The Standard uses the term translation unit rather
than source file because a single translation unit can be assembled from more than a single source file: A source file
and the header files that are #included in it are a single translation unit.
Program
A program consists of one or more translation units that are linked together.
Well-Formed Program
A well-formed program is one that is constructed according to the Standard's syntax and semantic rules and that obeys
the One Definition Rule (explained in the following section). An ill-formed program is one that does not meet these
requirements.
lvalues and rvalues
An object is a contiguous region of storage. An lvalue is an expression that refers to such an object. The original
definition of lvalue referred to an object that can appear on the left-hand side of an assignment. However, const
objects are lvalues that cannot be used in the left-hand side of an assignment. Similarly, an expression that can appear
in the right-hand side of an expression (but not in the left-hand side of an expression) is an rvalue. For example
#include <string>
using namespace std;
int& f();
void func()
{
int n;
char buf[3];
n = 5; // n is an lvalue; 5 is an rvalue
buf[0] = 'a'; // buf[0] is an lvalue, 'a' is an rvalue
string s1 = "a", s2 = "b", s3 = "c"; // "a", "b", "c" are rvalues
s1 = // lvalue
s2 +s3; //s2 and s3 are lvalues that are implicitly converted to rvalues
s1 = //lvalue
string("z"); //temporaries are rvalues
int * p = new int; //p is an lvalue; 'new int' is an rvalue
f() = 0; //a function call that returns a reference is an lvalue
s1.size(); //otherwise, a function call is an rvalue expression
}
An lvalue can appear in a context that requires an rvalue; in this case, the lvalue is implicitly converted to an rvalue.
An rvalue cannot be converted to an lvalue. Therefore, it is possible to use every lvalue expression in the example as
ANSI/ISO C++ Professional Programmer's Handbook - Chapter 2 - Standard Briefing: The Latest Addenda to ANSI/ISO C++
file:///D|/Cool Stuff/old/ftp/1/1/ch02/ch02.htm (4 von 24) [12.05.2000 14:45:45]
an rvalue, but not vice versa.
Behavior Types
The Standard lists several types of program behaviors, which are detailed in the following sections.
Implementation-Defined Behavior
Implementation-defined behavior (for a well-formed program and correct data) is one that depends on the particular
implementation; it is a behavior that each implementation must document. For example, an implementation
documents the size of fundamental types, whether a char can hold negative values, and whether the stack is
unwound in the case of an uncaught exception. Implementation-defined behavior is also called
implementation-dependent behavior.
Unspecified Behavior
Unspecified behavior (for a well-formed program and correct data) is one that depends on the particular
implementation. The implementation is not required to document which behavior occurs (but it is allowed to do so).
For example, whether operator new calls to the Standard C library function malloc() is unspecified. Following is
another example: The storage type for the temporary copy of an exception object is allocated in an unspecified way
(however, it cannot be allocated on the free store).
Implementation-defined behavior and unspecified behavior are similar. Both refer to consistent behavior that is
implementation-specific. However, unspecified behavior usually refers to the underlying mechanism of the
implementation, which users generally do not access directly. Implementation-dependent behavior refers to language
constructs that can be used directly by users.
Undefined Behavior
Undefined behavior is one for which the Standard imposes no requirements. This definition might sound like an
understatement because undefined behavior indicates a state that generally results from an erroneous program or
erroneous data. Undefined behavior can be manifested as a runtime crash or as an unstable and unreliable program
state -- or it might even pass unnoticed. Writing to a buffer past its boundary, accessing an out-of-range array
subscript, dereferencing a dangling pointer, and other similar operations result in undefined behavior.
Conclusions
Unspecified behavior and implementation-defined behavior are consistent -- albeit nonportable -- behaviors that are
left intentionally unspecified by the C++ Standard, usually to allow efficient and simple compiler implementation on
various platforms. Conversely, undefined behavior is always undesirable and should never occur.
The One Definition Rule
A class, an enumeration, an inline function with external linkage, a class template, a nonstatic function template, a
member function template, a static data member of a class template, or a template specialization for which some
template parameters are not specified can be defined more than once in a program -- provided that each definition
appears in a different translation unit, and provided that the definitions meet the requirements that are detailed in the
following sections.
Token-by-Token Identity
Each definition must contain the same sequence of tokens. For example
ANSI/ISO C++ Professional Programmer's Handbook - Chapter 2 - Standard Briefing: The Latest Addenda to ANSI/ISO C++
file:///D|/Cool Stuff/old/ftp/1/1/ch02/ch02.htm (5 von 24) [12.05.2000 14:45:45]
//file fisrt.cpp
inline int C::getVal () { return 5; }
//file sec.cpp
typedef int I;
inline I C::getVal () { return 5; } // violation of ODR,
// I and int are not identical tokens
On the other hand, white spaces and comments are immaterial:
//file fisrt.cpp
inline int C::getVal () { return 5; }
//file sec.cpp
inline int C::getVal () { /*complies with the ODR*/
return 5; }
Semantic Equivalence
Each token in the identical sequences of the separate definitions has the same semantic contents. For example
//file first.cpp
typedef int I;
inline I C::getVal () { return 5; }
//file second.cpp
typedef unsigned int I;
inline I C::getVal () { return 5; } //error; different semantic content for I
Linkage Types
A name that refers to an object, reference, type, function, template, namespace, or value that is declared in another
scope is said to have linkage. The linkage can be either external or internal. Otherwise, the name has no linkage.
External Linkage
A name that can be referred to from other translation units or from other scopes of the translation unit in which it was
defined has external linkage. Following are some examples:
void g(int n) {} //g has external linkage
int glob; //glob has external linkage
extern const int E_MAX=1024; //E_MAX has external linkage
namespace N
{
int num; //N::num has external linkage
void func();//N::func has external linkage
}
class C {}; //the name C has external linkage
Internal Linkage
A name that can be referred to by names from other scopes in the translation unit in which it was declared, but not
from other translation units, has internal linkage. Following are some examples:
ANSI/ISO C++ Professional Programmer's Handbook - Chapter 2 - Standard Briefing: The Latest Addenda to ANSI/ISO C++
file:///D|/Cool Stuff/old/ftp/1/1/ch02/ch02.htm (6 von 24) [12.05.2000 14:45:45]
剩余280页未读,继续阅读
阿莱
- 粉丝: 2
- 资源: 98
上传资源 快速赚钱
- 我的内容管理 展开
- 我的资源 快来上传第一个资源
- 我的收益 登录查看自己的收益
- 我的积分 登录查看自己的积分
- 我的C币 登录后查看C币余额
- 我的收藏
- 我的下载
- 下载帮助
最新资源
- 明日知道社区问答系统设计与实现-SSM框架java源码分享
- Unity3D粒子特效包:闪电效果体验报告
- Windows64位Python3.7安装Twisted库指南
- HTMLJS应用程序:多词典阿拉伯语词根检索
- 光纤通信课后习题答案解析及文件资源
- swdogen: 自动扫描源码生成 Swagger 文档的工具
- GD32F10系列芯片Keil IDE下载算法配置指南
- C++实现Emscripten版本的3D俄罗斯方块游戏
- 期末复习必备:全面数据结构课件资料
- WordPress媒体占位符插件:优化开发中的图像占位体验
- 完整扑克牌资源集-55张图片压缩包下载
- 开发轻量级时事通讯活动管理RESTful应用程序
- 长城特固618对讲机写频软件使用指南
- Memry粤语学习工具:开源应用助力记忆提升
- JMC 8.0.0版本发布,支持JDK 1.8及64位系统
- Python看图猜成语游戏源码发布
安全验证
文档复制为VIP权益,开通VIP直接复制
信息提交成功