精通C++/CLI：面向Visual C++程序员的.NET指南

3星 · 超过75%的资源需积分: 10 59 浏览量更新于2024-07-19 收藏 2.42MB PDF 举报

"Expert C++/CLI: .NET for Visual C++ Programmers 是一本由 Marcus Heege 编写的书籍，旨在帮助经验丰富的 C++ 开发者理解和利用 C++/CLI 这一语言扩展，以利用 .NET Framework 的功能。本书强调了 C++/CLI 与标准 C++ 的源代码兼容性，允许开发者在不离开熟悉的 C++ 环境的前提下，接入 .NET 平台的丰富资源。" C++/CLI 是 Microsoft 推出的一种语言规范，它是 C++ 的一个扩展，主要用于与 .NET Framework 集成。C++/CLI 保留了大量原始 C++ 的语法，但同时引入了对 .NET 框架特性的支持，如托管类型、引用类型、垃圾回收等。通过 C++/CLI，开发者可以在同一个项目中混合编写托管代码（与 .NET 兼容）和非托管代码（纯 C++），这在需要调用 C++ 库或利用 .NET 功能的场景中非常有用。 C++/CLI 的关键特性包括： 1. **托管类型（Managed Types）**：C++/CLI 引入了 `gcnew` 关键字来创建托管对象，这些对象由 .NET 的垃圾收集器管理内存。此外，`ref class` 和 `value class` 分别用于定义托管类和值类型。 2. **装箱和拆箱**：C++/CLI 支持装箱（Boxing）和拆箱（Unboxing）操作，使得值类型可以与 .NET 集合和其他通用接口一起使用。 3. **互操作性（Interoperability）**：C++/CLI 提供了与非托管代码交互的能力，例如使用 `pin_ptr` 和 `Platform::Agile` 类型来处理指针，确保数据在垃圾回收期间不会移动。 4. **泛型（Generics）**：C++/CLI 支持泛型，允许开发者编写可重用的类型模板，与 C# 和其他 .NET 语言的泛型兼容。 5. **托管和非托管转换**：通过 `__declspec(native)` 和 `__declspec.managed` 修饰符，可以明确指定代码是托管还是非托管，便于混合编程。书中的技术审阅者 Stanley Lippman 是 C++ 语言的重要人物，他的参与确保了书中的内容具有权威性和准确性。此书可能涵盖了 C++/CLI 的基础到高级主题，包括如何创建和使用托管类、与 .NET 库的集成、异常处理、线程同步、以及如何调试和优化 C++/CLI 代码等内容。通过学习 "Expert C++/CLI: .NET for Visual C++ Programmers"，读者可以掌握将现有 C++ 技能应用于 .NET 开发的技巧，从而更好地利用 .NET Framework 提供的各种服务和库，提升软件开发的效率和质量。

What Is C++/CLI?

C++/CLI is a set of extensions made to the C++ language to benefit from the services that an

implementation of the CLI offers. These extensions are published as the ECMA-372 standard.

With the help of these extensions, a programmer can use .NET constructs in existing C++

code, as shown previously. Visual C++ 2005 implements the C++/CLI standard to support

executing code on the CLR.

Building C++/CLI Applications

To make the switch from C to C++, a new file extension was used. As you can see in the pre-

ceding HelloWorld3.cpp example, the file extension for C++/CLI applications remains

unchanged. However, there is still a need to distinguish between C++ compilation and

C++/CLI compilation—the result of native C++ compilation is native code, whereas the result

of C++/CLI compilation is managed code. If you try to compile the code on the command line,

as shown in the following, you’ll get compiler errors.

CL.EXE HelloWorld3.cpp

These errors will complain that System is neither a class nor a namespace name, and that the

identifier WriteLine is not found. Both the namespace System and the method WriteLine are

the managed aspects of your code. The Visual C++ compiler can act as a normal C++ compiler

or as a C++/CLI compiler. By default, it remains a native compiler. To use it as a C++/CLI com-

piler, you use the compiler switch /clr, as in the following command line:

CL.EXE /clr HelloWorld3.cpp

This simple HelloWorld3 application shows one of the advantages that C++/CLI has over all

other commonly used .NET languages: it provides source code compatibility with a good old

native language.

C++/CLI is a superset of the C++ language. A valid C++ program is also a valid C++/CLI

program. As a consequence, your existing code base is not lost. Instead of reimplementing

existing applications with a completely new language and programming infrastructure, you

can seamlessly extend existing code with .NET features.

The HelloWorld3.exe file created by the C++/CLI compiler and linker is a so-called .NET

assembly. For this chapter, it is sufficient to consider assemblies as the deployable units of the

.NET world. Chapter 4 will provide a more detailed definition of this term. The

HelloWorld3.exe assembly differs from assemblies created by other .NET languages because it

contains native code as well as managed code. An assembly like HelloWorld3.exe is also called

a mixed-code assembly.

A migration strategy based on C++/CLI can preserve huge investments in existing C++

source code. This is extremely important because there is a vast amount of C++ code that is

already written, tested, accepted, and in service. Furthermore, this strategy allows a partial

migration with small iterations. Instead of switching everything to .NET in one chunk, you can

flexibly use different .NET features when they seem appropriate.

CHAPTER 1 ■ WHY C++/CLI? 3

// HelloWorld4.cpp

// compile with "cl /MD HelloWorld4.cpp /link ManagedCode.obj UnmanagedCode.obj"

#include <stdio.h>

extern void fManaged(); // implemented in ManagedCode.cpp

int main()

{

printf("Hi from native code.\n");

fManaged();

}

If you use the command shown in the comment of this code, the C++/CLI compiler will

generate a native object file, HelloWorld4.obj, and link it together with ManagedCode.obj and

UnmanagedCode.obj into the application HelloWorld4.exe. Since HelloWorld4.obj is a native

object file, HelloWorld4.exe has a native entry point. The printf call in main is a native call

from a native function. This call is done without a switch between managed and unmanaged

code. After calling printf, the managed function fManaged is called. When an unmanaged

function like main calls a managed function like fManaged, an unmanaged-to-managed transi-

tion takes place. When fManaged executes, it uses the managed Console class to do its output,

and then it calls the native function fNative. In this case, a managed-to-unmanaged transition

occurs.

The HelloWorld4 application was written to explain both kinds of transitions. It is

extremely helpful to have both these options and to control in a very fine-grained way when

a transition from managed code to unmanaged code, or from unmanaged code to managed

code, takes place. In real-world applications, it is important to avoid these transitions,

because method calls with these transitions are slower. Reducing these transitions is key to

avoiding performance penalties in C++/CLI. To detect performance problems, it can be very

important to identify transitions between managed and unmanaged code. Reducing perform-

ance penalties is often done by introducing new functions that replace a high number of

managed/unmanaged transitions with just one. Chapter 9 gives you detailed information

about internals of managed/unmanaged transitions.

The code samples used so far have used the simplest possible method signature. How-

ever, the interoperability features of C++/CLI allow you to use any native type in code that is

compiled to managed code. This implies that methods called via managed/unmanaged tran-

sitions can use any kind of native type. Chapter 8 will discuss all details of type transitions.

DLLs with Managed Entry Points

You can also factor managed code out into a separate DLL so that your existing projects

remain completely unmanaged. Figure 1-4 shows a simple example of such a scenario.

CHAPTER 1 ■ WHY C++/CLI? 7

剩余289页未读，继续阅读

liujun3&&df

粉丝: 0
资源: 1

精通C++/CLI：面向Visual C++程序员的.NET指南

Expert C++ / CLI .NET for Visual C++ Programmers (带完整目录)

Expert C++/CLI

C++/CLI入门指南：.NET for Visual C++

精通Visual C++/CLI：.NET编程指南

精通C++/CLI .NET：面向Visual C++程序员的指南

精通C++/CLI：Visual C++程序员的.NET指南

Visual C++程序员的C++/CLI与.NET专家指南

《Expert C++/CLI for Visual C++ Programmers》核心编程指南

C++/CLI专家指南：Visual C++程序员的.NET实战

expert c++&cli

最新资源