C++编程标准与指南

需积分: 1 110 浏览量更新于2024-07-26 收藏 2.21MB PDF 举报

"C++ 编程指导 - OMG C++ Language Mapping Version 1.2" 这篇文档是关于C++编程的指南，特别提到了"C++ Language Mapping"，这通常指的是将C++语言特性与特定的平台或标准进行映射，确保代码在不同环境下的兼容性和可移植性。该版本为1.2，发布日期为2008年1月，并由Object Management Group (OMG) 提供，这是一个知名的国际标准组织，致力于制定和推广软件标准，如CORBA（Common Object Request Broker Architecture）。 OMG Document Number formal/2008-01-09 指的是这个文档的官方编号，可以在OMG的官方网站上找到该规范的PDF版本。这个文档的版权由多家公司共享，包括Digital Equipment Corporation, Expersoft Corporation, Hewlett-Packard Company, IBM Corporation, IONATechnologies, Novell USG, ObjectManagementGroup, Inc., 和SunSoft, Inc.，显示了这个标准在业界的广泛参与和认可。文档中提到的“USE OF SPECIFICATION - TERMS, CONDITIONS & NOTICES”是指使用此规范的条款、条件和注意事项。用户被明确告知，这份文档仅详述了OMG的一个规范，并不构成任何公司实施该规范任何部分的承诺。此外，文档内容可能随时更改，而无需提前通知。各个列出的公司已经授予OMG非独占、免版税、一次性支付的全球许可，用于复制和分发此文档。 C++编程语言本身是一种强大的面向对象的编程语言，它在继承了C语言的效率和灵活性的同时，引入了类、模板、异常处理、多态等特性，使得软件设计更加模块化和易于维护。在实际开发中，C++的这些特性经常需要与具体平台的API或其他标准进行适配，这就需要理解C++语言映射的概念。这个文档可能是为了帮助开发者理解和应用这些映射规则，以便在不同的软件系统和环境中正确地使用C++。这份“C++ 编程指导”文档对深入理解C++语言和实现跨平台开发具有重要价值，特别是对于那些需要将C++代码与特定标准或平台集成的开发者而言。通过学习这份文档，开发者可以更好地掌握如何利用C++的强大功能来编写高效、可移植的代码。

4 C++ Language Mapping, v1.2

6 C++ Language Mapping, v1.2

E e;

e.L = 3;

To avoid C++ compilation problems, every use in OMG IDL of a C++ keyword as an identifier is mapped into the same

name preceded by the prefix “_cxx_.” For example, an IDL interface named “try” would be named “_cxx_try” when its

name is mapped into C++. For consistency, this rule also applies to identifiers that are derived from IDL identifiers. For

example, an IDL interface “try” generates the names “_cxx_try_var,” “_cxx_try_ptr,” and “_tc__cxx_try.”

The complete list of C++ keywords can be found in “C++ Keywords” on page 154.

4.2 C++ Type Size Requirements

The sizes of the C++ types used to represent OMG IDL types are implementation-dependent. That is, this mapping makes

no requirements as to the sizeof(T) for anything except basic types (see “Mapping for Basic Data Types” on page 15)

and string (see “Mapping for String Types” on page 17).

4.3 CORBA Module

The mapping relies on some predefined types, classes, and functions that are logically defined in a module named

CORBA

. The module is automatically accessible from a C++ compilation unit that includes a header file generated from

an OMG IDL specification. In the examples presented in this document, CORBA definitions are referenced without

explicit qualification for simplicity. In practice, fully scoped names or C++ using statements for the CORBA namespace

would be required in the application source. See The Common Object Request Broker: Application and Specifications,

Annex A for standard OMG IDL tags.

4.4 Mapping for Modules

As shown in “Scoped Names” on page 5, a module defines a scope, and as such is mapped to a C++ namespace with

the same name:

// IDL

module M

{

// definitions

};

// C++

namespace M

{

// definitions

}

Because namespaces were only recently added to the C++ language, few C++ compilers currently support them.

Alternative mappings for OMG IDL modules that do not require C++ namespaces are in “Alternative Mappings For C++

Dialects” on page 152.

4.5 Mapping for Interfaces

An interface is mapped to a C++ class that contains public definitions of the types, constants, operations, and exceptions

defined in the interface.

C++ Language Mapping, v1.2 7

A CORBA–C++–compliant program cannot

• create or hold an instance of an interface class, or

• use a pointer (A*) or a reference (A&) to an interface class.

The reason for these restrictions is to allow a wide variety of implementations. For example, interface classes could not

be implemented as abstract base classes if programs were allowed to create or hold instances of them. In a sense, the

generated class is like a namespace that one cannot enter via a using statement. This example shows the behavior of the

mapping of an interface:

// IDL

interface A

{

struct S { short field; };

};

// C++

// Conformant uses

A::S s; // declare a struct variable

s.field = 3; // field access

// Non-conformant uses:

// one cannot declare an instance of an interface class...

A a;

// ...nor declare a pointer to an interface class...

A *p;

// ...nor declare a reference to an interface class.

void f(A &r);

4.5.1 Object Reference Types

The use of an interface type in OMG IDL denotes an object reference. Because of the different ways an object reference

can be used and the different possible implementations in C++, an object reference maps to two C++ types. For an

interface

A, these types are named A_var and A_ptr. To facilitate template-based programming, typedefs for the

A_ptr and A_var types are also provided in the interface class (see “Interface Mapping Example” on page 11). The

typedef for A_ptr is named A::_ptr_type and the typedef for A_var is named A::_var_type.

An operation can be performed on an object by using an arrow (“->”) on a reference to the object. For example, if an

interface defines an operation op with no parameters and obj is a reference to the interface type, then a call would be

written obj->op(). The arrow operator is used to invoke operations on both the _ptr and _var object reference types.

Client code frequently will use the object reference variable type (A_var) because a variable will automatically release

its object reference when it is deallocated or when assigned a new object reference. The pointer type (A_ptr) provides a

more primitive object reference, which has similar semantics to a C++ pointer. Indeed, an implementation may choose to

define A_ptr as A*, but is not required to. Unlike C++ pointers, however, conversion to void*, arithmetic operations,

and relational operations, including test for equality, are all non-compliant. A compliant implementation need not detect

these incorrect uses because requiring detection is not practical.

8 C++ Language Mapping, v1.2

For many operations, mixing data of type A_var and A_ptr is possible without any explicit operations or casts.

However, one needs to be careful in doing so because of the implicit release performed when the variable is deallocated.

For example, the assignment statement in the code below will result in the object reference held by p to be released at the

end of the block containing the declaration of a.

// C++

A_var a;

A_ptr p = // ...somehow obtain an objref...

a = p;

4.5.2 Widening Object References

OMG IDL interface inheritance does not require that the corresponding C++ classes are related, though that is certainly

one possible implementation. However, if interface B inherits from interface A, the following implicit widening

operations for B must be supported by a compliant implementation:

• B_ptr to A_ptr

• B_ptr to Object_ptr

• B_var to A_ptr

• B_var to Object_ptr

Implicit widening from a B_var to A_var or Object_var is not supported; instead, widening between _var types for

object references requires a call to _duplicate (described in “Object Reference Operations” on page 9).

An attempt to

implicitly widen from one _var type to another must cause a compile-time error.

Assignment between two _var objects

of the same type is supported, but widening assignments are not and must cause a compile-time error. Widening

assignments may be done using _duplicate. The same rules apply for object reference types that are nested in a

complex type, such as a structure or sequence.

// C++

B_ptr bp = ...

A_ptr ap = bp; // implicit widening

Object_ptr objp = bp; // implicit widening

objp = ap; // implicit widening

B_var bv = bp; // bv assumes ownership of bp

ap = bv; // implicit widening, bv retains

// ownership of bp

obp = bv; // implicit widening, bv retains

// ownership of bp

A_var av = bv; // illegal, compile-time error

A_var av = B::_duplicate(bv);// av, bv both refer to bp

B_var bv2 = bv; // implicit _duplicate

1. When T_ptr is mapped to T*, it is impossible in C++ to provide implicit widening between T_var types while also providing the

necessary duplication semantics for

T_ptr types.

2. This can be achieved by deriving all

T_var types for object references from a base _var class, then making the assignment operator

for

_var private within each T_var type.

剩余171页未读，继续阅读

freesky114

粉丝: 1
资源: 7

C++编程标准与指南

C++编程指导(编程要注意的细节)

C++入门编程指导资料

C++编程指导：规则与忠告

Bjarne Stroustrup的C++编程指导原则

C++编程指导：特别版忠告与实践原则

C++编程规范指导

C++ 编程风格指导

C++编程思想 C++ C++教程 C++编程思想 嵌入式编程 编程 编程思想

C & C++ 编程风格指导.rar

《C++编程思想》C++编程思想

最新资源

C++编程思想 C++ C++教程 C++编程思想嵌入式编程编程编程思想