C++/CLI实战指南：打通原生C++与.NET托管代码的桥梁

1. 项目概述：C++与托管代码的桥梁

很多从传统C++转向.NET平台开发的开发者，心里都会冒出一个问号：我熟悉的C++，能直接用来写托管代码吗？答案是肯定的，但实现方式和我们熟悉的“原生C++”有本质区别。这里的关键角色，就是C++/CLI。它并不是一个全新的语言，而是微软为Visual C++引入的一组语言扩展，专门用来在.NET公共语言运行时（CLR）上编写托管代码。你可以把它理解成C++和.NET世界之间的一座“特制桥梁”，让你既能保留C++的语法习惯和性能优势，又能无缝调用.NET Framework或.NET Core/.NET 5+中庞大的类库。

很多人会把C++/CLI和历史上的“托管C++”（Managed C++）混为一谈，这其实是一个常见的误解。“托管C++”是Visual C++ .NET 2002/2003时代的技术，其语法和设计存在不少问题，后来被彻底重新设计的C++/CLI所取代。C++/CLI在语法上更清晰、更符合C++标准，并且与CLR的集成度更高。所以，当我们今天谈论用C++写托管代码，指的就是C++/CLI。

那么，用C++/CLI写托管代码，和写原生C++程序到底有什么不同？最核心的区别在于“谁在管理内存”。原生C++里，你通过 new 和 delete 手动管理堆内存，一个不小心就是内存泄漏或野指针。而在C++/CLI的托管世界里，对象分配在CLR管理的堆上，由垃圾回收器（GC）自动负责回收不再使用的内存，这大大减轻了开发者的负担。此外，你编写的类型（类、结构体）都成为了.NET类型体系的一部分，可以被C#、VB.NET等其他.NET语言直接使用，反之亦然。

这篇文章，我将从一个有十多年C++和.NET混合开发经验的开发者角度，带你彻底搞懂C++/CLI。我们会从核心概念讲起，通过一个完整的简单示例上手实操，再深入剖析其内部机制、与原生C++的互操作技巧，以及在实际项目中如何避坑。无论你是想将遗留的C++代码库迁移到.NET平台，还是需要在.NET应用中集成高性能的C++模块，这篇文章都能给你提供清晰的路径和实用的代码。

2. C++/CLI核心概念深度解析

2.1 托管代码 vs 原生代码：运行时的根本差异

要理解C++/CLI，必须先厘清“托管”和“原生”这两个概念。这不是简单的语法差异，而是整个程序生命周期管理方式的革命。

原生C++代码编译后，生成的是直接面向特定操作系统和CPU架构的本地机器码（Native Code）。你的程序直接与操作系统API对话，自己管理内存、线程、文件句柄等一切资源。它的优势是极致性能和底层控制力，但代价是开发者需要承担所有的管理责任，平台移植性也相对较差。

托管代码则运行在CLR这个“虚拟机”之上。你用C++/CLI（或C#）写的源代码，首先被编译成一种中间语言（IL，Intermediate Language），而不是直接的机器码。当程序运行时，CLR的即时编译器（JIT）才会把IL代码动态编译成本地代码执行。CLR提供了包括垃圾回收（GC）、异常处理、安全检查、线程管理等一系列运行时服务。这意味着：

1. 内存自动管理 ：你使用 gcnew （而不是 new ）创建对象，GC会在后台跟踪对象引用，并在适当的时候回收内存。这几乎杜绝了内存泄漏，但引入了非确定性回收的特性。
2. 类型安全与验证 ：CLR会在加载和执行程序集时进行严格的类型安全检查，防止很多常见的缓冲区溢出和类型转换错误。
3. 跨语言互操作性 ：因为所有.NET语言都编译成标准的IL，并遵循共同的类型系统（CTS），所以C++/CLI写的类可以直接被C#继承，反之亦然。
4. 版本控制与部署 ：.NET程序集包含丰富的元数据，支持并行部署和更健壮的版本控制。

一个重要的实操心得 ：不要把托管代码想象成“慢代码”。经过JIT优化后的托管代码性能非常接近原生代码，尤其是在长时间运行的服务器端应用中。性能瓶颈往往出现在不恰当的数据封送（Marshaling）或过于频繁的托管/原生切换上，而不是托管机制本身。

2.2 C++/CLI语法扩展与关键符号

C++/CLI在标准C++语法基础上，引入了一些新的关键字和符号来标识托管实体。这些是阅读和编写C++/CLI代码的“密码”。

• 引用类型（Ref Class） ：使用 ref class 或 ref struct 声明。这是托管堆上的对象，通过跟踪句柄（Tracking Handle）来引用。句柄使用 ^ 符号（读作“hat”），类比于原生C++的指针 * ，但语义不同。 ^ 表示一个由GC管理的引用，你不能对它进行指针算术运算，GC可以移动它指向的对象，并自动更新所有 ^ 的值。

  ref class ManagedPerson { // 引用类型，分配在托管堆
  public:
      property String^ Name; // 属性，.NET的特色功能
      void SayHello() { Console::WriteLine("Hello, {0}!", Name); }
  };
  

• 值类型（Value Type） ：使用 value class 或 value struct 声明。类似于C#的 struct ，分配在线程栈或作为其他对象的嵌入字段。它通常用于存储小型数据，按值拷贝。

  value struct Point { // 值类型，通常分配在栈上
      int X;
      int Y;
  };
  

• 对象创建 ：使用 gcnew 关键字在托管堆上创建引用类型实例。它返回一个跟踪句柄（ ^ ）。

  ManagedPerson^ person = gcnew ManagedPerson();
  person->Name = "Alice"; // 使用 -> 操作符访问成员
  

• 接口与抽象类 ：语法与C++类似，但运行在托管环境中。使用 interface class 声明接口。

  interface class IDrawable {
      void Draw();
  };
  ref class Circle : IDrawable {
  public:
      virtual void Draw() override { /* 绘制圆形 */ }
  };
  

• 属性（Property） ：.NET的特色，使用 property 关键字定义，为字段提供getter和setter访问器。
• 委托（Delegate）与事件（Event） ：完全支持.NET的事件模型。

注意事项 ： ref class 不能像原生C++类那样多重继承（只能继承自一个托管类），但可以实现多个托管接口。这是CTS的规定。

2.3 与“托管C++”的历史纠葛与澄清

“托管C++”（Managed C++）是微软最初的尝试，在Visual Studio .NET 2002中引入。它的语法非常“丑陋”，为了区分托管和原生指针，它使用了双下划线 __gc 等前缀，并且将托管类型和原生类型混杂在一起，导致代码可读性极差。例如：

// 古老的托管C++语法 (已过时，切勿在新项目中使用)
__gc class OldManagedClass {
    String* name; // 注意这里用的是原生指针风格的`*`，但实际上指向托管对象
};

由于社区反馈不佳，微软彻底重新设计了这门语言，并在Visual Studio 2005中推出了C++/CLI。新语法（ ref class , ^ , gcnew ）更加清晰、优雅，并且努力与标准C++的语法风格保持一致。因此， C++/CLI是“托管C++”的正式继任者和现代化版本 。任何新项目都应使用C++/CLI，而“托管C++”代码应尽快迁移。

3. 从零开始：你的第一个C++/CLI项目

3.1 开发环境配置与项目创建

你需要Visual Studio。社区版是免费的，完全够用。确保在安装时勾选了“使用C++的桌面开发”工作负载，其中包含了C++/CLI支持。

创建项目的步骤：

1. 打开Visual Studio，选择“创建新项目”。
2. 在搜索框中输入“CLI”，选择“CLR空项目”或“CLR控制台应用”。我建议从“CLR空项目”开始，更能理解其构成。
3. 为项目命名，例如“FirstCppCli”，选择位置后点击“创建”。

创建完成后，在“解决方案资源管理器”中，右键点击“源文件”文件夹，选择“添加” -> “新建项”。选择“C++文件(.cpp)”，命名为 Main.cpp 。

一个关键的配置点 ：项目属性。右键点击项目，选择“属性”。在“配置属性” -> “常规”中，确保“公共语言运行时支持”设置为“公共语言运行时支持(/clr)”。这就是启用C++/CLI编译的核心开关。你还可以选择“/clr:pure”（纯IL）或“/clr:safe”（安全可验证代码），但对于需要与原生代码互操作的情况，默认的 /clr 即可。

3.2 一个完整的“Hello World”及类型交互示例

让我们写一个比简单输出更丰富的示例，展示托管类型、值类型以及调用.NET Framework类库。

// Main.cpp
#include "stdafx.h" // 预编译头，在空项目中可能需要手动添加或关闭
using namespace System;
using namespace System::Collections::Generic;

// 1. 定义一个托管引用类型 (Ref Class)
ref class Student {
public:
    // 属性
    property String^ Name;
    property int Age;

    // 构造函数
    Student(String^ name, int age) : Name(name), Age(age) {}

    // 方法
    void Introduce() {
        Console::WriteLine("Hi, I'm {0}, {1} years old.", Name, Age);
    }
};

// 2. 定义一个值类型 (Value Type)
value struct Score {
    int Math;
    int English;
    int Programming;

    // 值类型可以有方法
    int Total() {
        return Math + English + Programming;
    }
};

// 主函数
int main(array<System::String^>^ args) {
    Console::ForegroundColor = ConsoleColor::Cyan;
    Console::WriteLine("=== C++/CLI Demo Start ===");
    Console::ResetColor();

    // 3. 使用托管类型
    Student^ student1 = gcnew Student("Alice", 20);
    Student^ student2 = gcnew Student("Bob", 22);
    student1->Introduce();
    student2->Introduce();

    // 4. 使用值类型 (在栈上分配)
    Score aliceScore;
    aliceScore.Math = 90;
    aliceScore.English = 85;
    aliceScore.Programming = 95;
    Console::WriteLine("{0}'s total score: {1}", student1->Name, aliceScore.Total());

    // 5. 使用.NET泛型集合 (List<T>)
    List<Student^>^ studentList = gcnew List<Student^>();
    studentList->Add(student1);
    studentList->Add(student2);
    studentList->Add(gcnew Student("Charlie", 21));

    Console::WriteLine("\nAll Students:");
    for each (Student^ stu in studentList) { // C++/CLI特有的 for each 循环
        stu->Introduce();
    }

    // 6. 与命令行参数交互
    if (args->Length > 0) {
        Console::WriteLine("\nCommand-line arguments:");
        for (int i = 0; i < args->Length; ++i) {
            Console::WriteLine("  Arg[{0}] = {1}", i, args[i]);
        }
    }

    Console::ForegroundColor = ConsoleColor::Green;
    Console::WriteLine("\n=== Demo Finished ===");
    Console::ResetColor();

    Console::ReadKey(); // 等待按键，防止控制台窗口一闪而过
    return 0;
}

代码解析与实操要点 ：

1. ref class Student ：定义了一个托管类。注意构造函数初始化列表的语法和原生C++一致。
2. value struct Score ：定义了一个值类型。它通常用于小型数据结构。 Total() 方法展示了值类型也可以有成员函数。
3. gcnew ：这是创建托管堆对象的唯一方式。它返回一个跟踪句柄 ^ 。
4. for each ：这是C++/CLI为遍历.NET集合提供的语法糖，比使用迭代器更简洁。
5. array<System::String^>^ args ： main 函数的参数是一个托管字符串数组，这是CLR控制台项目的标准签名。
6. Console::ForegroundColor ：我们直接使用了 System 命名空间下的 Console 类，展示了与.NET Framework BCL（基础类库）的无缝集成。

编译并运行这个程序，你会看到一个彩色的控制台输出，演示了类型创建、集合使用和参数处理。这已经是一个功能完整的托管应用程序了。

3.3 项目结构分析与编译过程

在解决方案目录下，你会发现除了 .vcxproj 项目文件，编译后还会生成一个 .exe 文件。用ILDasm（.NET反汇编器）工具打开这个 .exe ，你会看到它包含IL代码和丰富的元数据，是一个标准的.NET程序集。同时，因为这个程序也链接了C++运行时库，它也是一个本地可执行文件。这就是C++/CLI混合程序集的特点：它同时包含托管IL代码和本地机器码。

编译过程简述 ：

1. C++/CLI编译器（cl.exe）在 /clr 开关下，会将你的源代码同时编译为IL和本地代码。
2. 对于纯粹的托管类型（如 ref class ），其方法体被编译成IL。
3. 对于函数中的本地变量和逻辑，编译器可能直接生成优化的本地代码，或者生成IL再由JIT编译。
4. 链接器（link.exe）将生成的对象文件、必要的.NET程序集（如mscorlib.dll）以及C++运行时库链接在一起，最终生成混合程序集。

4. C++/CLI与原生C++的互操作实战

C++/CLI最强大的价值在于作为“粘合剂”，在托管世界和原生C++世界之间架起桥梁。你可以在同一个项目、甚至同一个文件里混合编写两种代码。

4.1 在托管代码中调用原生C++函数和类

假设我们有一个用原生C++编写的高性能数学库，我们想在C# GUI程序中使用它。C++/CLI是完美的包装层。

首先，创建一个原生C++类（头文件和源文件）：

// NativeMath.h
#pragma once
class NativeMath {
public:
    // 一个计算密集型的原生函数
    static double ComputePi(int iterations);
};

// NativeMath.cpp
#include "NativeMath.h"
#include <cmath>
double NativeMath::ComputePi(int iterations) {
    double sum = 0.0;
    for (int i = 0; i < iterations; ++i) {
        double term = (i % 2 == 0) ? 1.0 : -1.0;
        term /= (2 * i + 1);
        sum += term;
    }
    return 4.0 * sum; // 莱布尼茨公式求Pi
}

然后，创建一个C++/CLI包装类来暴露这个功能给.NET：

// ManagedMathWrapper.h
#pragma once
#include "NativeMath.h" // 包含原生头文件

namespace MathBridge {
    public ref class ManagedMath {
    public:
        // 包装原生静态方法
        static double ComputePi(int iterations) {
            // 直接调用原生C++函数！
            return NativeMath::ComputePi(iterations);
        }

        // 包装原生对象实例
        double InstanceCompute(int iterations) {
            if (!_nativeInstance) {
                _nativeInstance = new NativeMath(); // 使用 new 创建原生对象
            }
            // 这里需要将原生对象指针转换为某种形式来调用方法。
            // 但我们的NativeMath::ComputePi是静态的，所以这里只是示例。
            // 对于实例方法，需要通过 _nativeInstance 指针调用。
            return NativeMath::ComputePi(iterations); // 仍调用静态方法示例
        }
    private:
        ~ManagedMath() { this->!ManagedMath(); } // 析构函数
        !ManagedMath() { // 终结器 (Finalizer)
            delete _nativeInstance;
            _nativeInstance = nullptr;
        }
        NativeMath* _nativeInstance; // 原生指针！
    };
}

关键点与避坑指南 ：

1. 原生指针 * 与托管句柄 ^ 共存 ：在C++/CLI类中，你可以同时拥有原生指针成员（ NativeMath* ）和托管句柄成员。这是互操作的核心。
2. 资源管理 ：原生对象（用 new 创建）不受GC管理。你 必须 手动释放它们，否则会导致内存泄漏。最佳实践是在托管包装类的析构函数（ ~ManagedMath ）或终结器（ !ManagedMath ）中释放原生资源。遵循RAII（资源获取即初始化）模式，在构造函数中获取资源，在析构函数中释放。
3. 直接调用 ：在C++/CLI方法内部，你可以像在普通C++中一样直接调用原生函数、访问原生变量，无需任何特殊的编组（Marshaling）开销。这是性能关键。

4.2 在原生C++中回调托管代码（函数指针与委托）

互操作不仅是单向的。原生代码也可能需要调用回托管代码，例如通知进度、处理事件。这需要将.NET委托（Delegate）转换为原生函数指针。

// 在ManagedMathWrapper.h中增加
namespace MathBridge {
    public delegate void ProgressCallback(int percent); // 声明一个托管委托

    public ref class ManagedMathWithCallback {
    public:
        // 接受一个托管委托作为参数
        static double ComputePiWithCallback(int iterations, ProgressCallback^ callback) {
            double sum = 0.0;
            for (int i = 0; i < iterations; ++i) {
                // ... 计算过程 ...
                if (callback != nullptr && (i % 10000 == 0)) {
                    int percent = (i * 100) / iterations;
                    callback->Invoke(percent); // 调用托管回调
                }
            }
            return 4.0 * sum;
        }
    };
}

在C#端，你可以这样调用：

// C# 代码
MathBridge.ManagedMathWithCallback.ComputePiWithCallback(1000000, percent => {
    Console.WriteLine($"Progress: {percent}%");
});

更复杂的情况 ：如果原生C++库期望一个标准的C函数指针（ void (*callback)(int) ），你需要使用 Marshal::GetFunctionPointerForDelegate 将委托转换为函数指针，并小心地保持委托对象不被GC回收（通常通过 GCHandle 来固定）。

4.3 数据封送（Marshaling）关键技巧

当数据在托管和原生边界之间传递时，如果类型不直接兼容，就需要进行封送处理。C++/CLI在简单情况下会自动处理（称为“blittable”类型，如 int , double , bool ）。

但对于字符串、数组、复杂结构体，你需要特别注意：

• 字符串 ： System::String^ 到 const char* 或 const wchar_t* 。

  #include <msclr/marshal.h>
  using namespace msclr::interop;
  void NativeFunction(const char* nativeStr) { /* ... */ }
  void CallNative() {
      String^ managedStr = "Hello from .NET";
      // 自动封送，在marshal_context生命周期内有效
      marshal_context context;
      NativeFunction(context.marshal_as<const char*>(managedStr));
  } // context析构时释放内存
  

• 数组 ：托管数组 array<int>^ 到原生指针 int* 。可以使用 pin_ptr 来固定托管数组在内存中的位置，防止GC在原生代码访问时移动它。

  void ProcessArray(array<int>^ managedArr) {
      pin_ptr<int> pinnedArr = &managedArr[0]; // 固定数组
      int* nativePtr = pinnedArr; // 获取原生指针
      // 现在可以安全地将 nativePtr 传递给原生函数
      SomeNativeFunction(nativePtr, managedArr->Length);
  } // pinnedArr 离开作用域，固定解除
  

重要警告 ：错误的数据封送是C++/CLI编程中最常见的崩溃来源。务必确保在原生代码使用数据期间，对应的托管内存被正确固定（pinned），并且理解各种封送辅助类（如 marshal_context , marshal_as , pin_ptr ）的生命周期和用法。

5. 高级主题与性能优化策略

5.1 混合模式程序集与纯IL模式

使用 /clr 编译选项创建的是 混合模式程序集 ，它既包含IL代码，也包含x86/x64本地代码。这是最常见的模式，允许无缝的互操作。

/clr:pure 选项（已过时，VS2017后基本移除）会生成 纯IL程序集 ，它不包含任何本地代码，所有方法（包括标准C++库函数）都被编译成IL。这种程序集是完全可验证的，安全性更高，但性能可能略有损失，且不能包含任何原生代码（如内联汇编或特定的编译器内置函数）。

/clr:safe 选项生成 可验证的IL程序集 ，并且禁止使用任何非托管指针和原生类型，确保代码是类型安全的。它通常用于需要最高安全性的场景（如某些SQL Server CLR集成）。

对于大多数互操作场景，标准的 /clr 是最佳选择。

5.2 性能关键路径优化

在性能敏感的代码段，频繁的托管/原生切换（称为“上下文切换”）会成为瓶颈。优化策略如下：

1. 批处理 ：不要在每个小操作上都跨越边界。例如，如果原生函数需要处理一个数组，一次性传递整个数组，而不是在循环中多次调用托管函数获取单个元素。
2. 减少封送开销 ：对于复杂数据，考虑在边界两侧使用相同的内存布局（例如，在托管端使用 value struct ，在原生端使用相同的 struct ），并通过 pin_ptr 直接共享内存，避免复制。
3. 将计算密集型循环留在原生侧 ：如果某段逻辑主要是数值计算，尽量用原生C++实现，并通过C++/CLI包装暴露一个粗粒度的接口给.NET调用。
4. 谨慎使用 virtual 和 interface ：托管虚方法和接口调用比原生虚函数调用开销稍大。在绝对性能关键的路径上，可以考虑使用基于函数指针或模板的策略模式（在原生侧实现）。

5.3 内存与资源管理最佳实践

1. 确定性资源释放 ：对于封装了原生资源（文件句柄、网络连接、GPU内存）的托管类，实现 IDisposable 接口（在C++/CLI中是定义析构函数 ~Class ）。这样C#的 using 语句可以正确工作。记住，C++/CLI的析构函数会编译成 Dispose 方法。
2. 避免循环引用 ：托管对象之间的循环引用会导致GC无法回收，即使这些对象已不再使用。如果循环引用中包含原生对象指针，情况更复杂。使用弱引用（ WeakReference ）来打破非必要的强引用循环。
3. finalizer （终结器）是最后保障 ：只在类持有非托管资源且用户可能忘记调用 Dispose 时实现终结器（ !Class ）。终结器有性能开销，且调用时机不确定。
4. 使用智能指针管理原生资源 ：在C++/CLI代码的原生部分，尽量使用 std::unique_ptr 或 std::shared_ptr 来管理原生资源，这可以大大减少手动管理导致的错误。

6. 常见问题、调试技巧与实战心得

6.1 编译与链接常见错误

• LNK2028: 无法解析的外部符号 ：这通常是因为在托管函数中声明了原生函数，但没有找到其实现。确保原生部分的 .cpp 文件被包含在项目中并参与编译。对于来自外部库的函数，确保正确链接了对应的 .lib 文件。
• C3828: 放置参数不兼容 ：当试图将原生C++对象（尤其是带有虚函数表的对象）作为托管类的成员时可能会发生。通常的解决方案是使用原生指针（ NativeClass* ）来持有它，而不是尝试按值嵌入。
• “/clr”与某些编译器选项不兼容 ：例如， /RTC1 （运行时检查）与 /clr 不兼容。在项目属性中， /clr 选项会自动调整其他一些编译选项。

6.2 运行时典型异常与调试

• System.AccessViolationException （访问冲突） ：这是最可怕的错误，通常意味着原生代码通过一个无效的指针（可能是已释放的内存）进行了访问。 调试方法 ：在Visual Studio调试器中，启用“仅我的代码”和“启用本机代码调试”。当异常抛出时，查看调用堆栈，找到从托管代码跳转到原生代码的边界点，检查传递的指针参数是否有效。大量使用 pin_ptr 确保托管内存不被GC移动。
• System.Runtime.InteropServices.SEHException ：这是结构化异常（Structured Exception Handling）的托管包装，通常也是原生代码中发生的访问冲突、除零等错误的信号。调试方法与上述类似。
• 内存泄漏 ：托管部分的内存由GC管理，但原生部分的内存需要手动管理。使用Visual Studio的“诊断工具”窗口中的“内存使用量”快照功能，对比操作前后的原生堆内存增量，来定位原生内存泄漏。对于简单的泄漏， _CrtDumpMemoryLeaks() 函数在调试版本中仍然有效。
• 使用混合模式调试器 ：这是最重要的工具。在项目属性 -> “调试”中，确保“调试器类型”设置为“混合”或“自动”。这样你可以在同一调试会话中，在托管代码和原生代码中无缝设置断点、查看变量。

6.3 项目迁移与集成实战心得

1. 增量迁移 ：不要试图一次性将庞大的原生C++库全部用C++/CLI重写。策略是“封装，而非重写”。首先为最核心、最需要被.NET调用的功能创建薄薄的C++/CLI包装层。保持大部分原生代码不变。
2. 接口设计 ：设计托管包装接口时，应使其符合.NET的惯用法（例如，使用属性、事件、集合接口 IEnumerable<T> ），而不是简单暴露原生API。这会让C#端的调用体验更好。
3. 处理平台调用（P/Invoke）的替代 ：如果你现有的C#代码通过P/Invoke调用一个复杂的C++库，并且遇到性能或封送问题，考虑用C++/CLI重写该交互层。C++/CLI的互操作开销通常远低于P/Invoke。
4. 单元测试 ：为C++/CLI包装层编写单元测试至关重要。你可以使用.NET的测试框架（如MSTest、NUnit）。测试应覆盖正常的调用路径，以及边界情况（如传递 nullptr 、处理异常从原生代码传播到托管代码）。
5. 部署 ：你的C++/CLI程序集可能依赖特定版本的VC++运行时（如msvcr140.dll）和.NET Framework/.NET运行时。确保在部署包中包含这些依赖项，或明确告知用户安装前提。可以使用“合并模块”或静态链接部分C++运行时库来简化部署。

C++/CLI是一个强大的工具，但它要求开发者同时深刻理解C++和.NET两个世界。它最适合的场景是系统级编程、高性能计算库的封装、大型遗留C++应用程序的现代化改造。当你需要.NET的生产力与C++的性能和控制力相结合时，C++/CLI往往是那个不二之选。掌握它，就等于在技术栈中拥有了一座连接两大生态的坚固桥梁。