2603C++,C++强项

哪些领域必须用c++而不是c#

C++的世界,有4个C#难以触及的禁区

我一直认为自己是C系,从C到C++再到C#,然后又返回C++.

我曾一度认为后者是前者的升级,但经历多了我发现,在有些地方C++不是一个可选项,而是唯一解.

下面这四个领域,就是我这些年用血泪换来的认知,在我这,它们是绝对是C#的禁区.

一,硬实时系统:当1毫秒的迟疑就是灾难

C#的GC就是原罪

在工业领域里,软件不仅要算得对,更要准时.一个控制指令晚了千分之一秒,后果可能是机械臂撞毁.

这种对时间的要求叫硬实时.C#的GC,无论吹得多么先进,它总是可能在未知时刻触发一次Stoptheworld,冻结你所有线程去回收内存.

该停顿对桌面程序无伤大雅,但对硬实时系统,就是死刑.
C++绝对的内存控制,从源消灭不确定性.

在C++里,能在启动系统时就规划好全部内存,彻底禁止运行时的动态赋值内存.原位新和内存池技术,能在一个预赋值好的,绝对安分的内存区域里创建和析构对象,整个过程``零成本,零延迟,完全可预测.

看代码,这才是硬实时系统里内存该有的样子:

  //一个为电机控制设计的,无锁的,`固定大小`指令池
  //它在`编译时`就确定了大小和`内存布局`
#include <array>
#include <cstddef>
#include <iostream>
  //指令结构,注意它的对齐,保证高效访问
alignas(64) struct MotorCommand {
  uint32_t motor_id;
  double target_velocity;
  double target_torque;
};
  //一个在`栈上或静态区`赋值的,
  //`编译期`确定的内存池,零动态赋值,零`运行时`成本
template<size_t POOL_SIZE>
class StaticCommandPool {
private:
  alignas(64) std::array<std::byte, POOL_SIZE * sizeof(MotorCommand)> memory_block;
  std::array<bool, POOL_SIZE> is_used;
  size_t next_ = 0;
public:
  StaticCommandPool() : is_used_{} {}
  // 全部按`假`初化
  MotorCommand* acquire() {
  //这是一个极简的,非线安的赋值策略,仅为说明
    for (size_t i = 0; i < POOL_SIZE ; ++i) {
      if (!is_used_[i]) {
        is_used_[i] = true;
        void* place = &memory_block_[i * sizeof(MotorCommand)];
  //`原位新`:在指定`内存地址`上`构造对象`,不触发堆赋值
        return new(place) MotorCommand();
      }
    }
    return nullptr;
  //在`硬实时系统`中,即`设计容量不足`,是致命错误
  }
  void release(MotorCommand* cmd) {
    if (!cmd) return;
  //`显式调用``析构器`
    cmd->~MotorCommand();
  //计算索引并按未使用标记
    ptrdiff_t index = (reinterpret_cast<std::byte*>(cmd) - memory_block_.data()) / sizeof(MotorCommand);
    if (index >= 0 && index < POOL_SIZE) {
      is_used_[static_cast<size_t>(index)] = false;
    }
  }
};
  // 模拟`1kHz`控制循环
void real_time_loop() {
  StaticCommandPool<16> pool;
  //在栈上创建,`生命期`跟随函数
  for(int tick = 0; tick < 10000 ; ++tick) {
    MotorCommand* cmd = pool.acquire();
    if (!cmd) {
  //触发紧急停机程序
      std::cerr << "FATAL: Command pool exhausted at tick " << tick << std::endl;
      return;
    }
    cmd->motor_id = 1;
    cmd->target_velocity = 1500.0;
    cmd->target_torque = 2.5;
    pool.release(cmd);
  }
  std::cout << "成功循环" << std::endl;
}

在硬实时领域,C++的确定性是生存的必要条件,而C#的GC让它天生就出局.

二,极限性能计算:当每一条CPU指令都要计较

C#无法保证最优的数据布局和指令映射.

在科学计算,气象模拟,图形渲染等场景,追求的是极致的计算吞吐量.这需要代码和数据在内存中的组织方式高度匹配CPU的架构,特别是要最大化利用CPU缓存和SIMD单元.

C++精确的内存布局+零成本的硬件指令抽象.
C++允许创建平坦的,连续的,精确对齐的内存块,这正是CPU缓存最喜欢的.更重要的是,它可用内联函数几乎无损地将C++代码直接翻译成底层的SIMD指令,比如AVX,用一条指令同时处理8个甚至16个浮点数.

看代码,如何用C++压榨CPU的:

  // 使用`IntelAVX2``指令集`,批量更新一百万个粒子位置
#include <vector>
#include <immintrin.h>
  //`AVX``指令集``头文件`
#include <chrono>
#include <iostream>
const int NUM_PARTICLES = 1024 * 1024;
  //包含`位置和速度`的粒子结构,
  //使用`alignas`确保每个结构都从`32`字节边框开始,方便`AVX`加载
struct alignas(32) Particle {
  float pos_x, pos_y, pos_z, w;
  //用w来凑齐`32`字节
  float vel_x, vel_y, vel_z, w2;
};
void update_particles(std::vector<Particle>& particles, float delta_time) {
  // 将`delta_time`广播到`256`位向量的所有通道
  __m256 dt_vec = _mm256_set1_ps(delta_time);
  //掩码,用来指定只更新位置分量(低4个`浮点数`)
  __m256i mask = _mm256_set_epi32(0, 0, 0, 0, -1, -1, -1, -1);
  for (size_t i = 0; i < particles.size() ; ++i) {
  //`1`.安全地加载整个粒子(`位置+速度`)到`256`位`寄存器`
    __m256 p_vec = _mm256_load_ps(&particles[i].pos_x);
  //`2`.构造一个纯`速度向量`
  //将原向量的高`128`位(速度),复制,在新向量的高低位
    __m256 vel_vec = _mm256_permute2f128_ps(p_vec, p_vec, 0x11);
   //`3`.核心计算:`pos_new=pos_old+vel*delta_time`
  //该指令会同时计算两个`128`位通道,只关心低通道的结果
  //低通道:`new_pos=p_vec.  lo+vel_vec.lo*dt=pos+vel*dt`(`正确`)
  //高通道:`new_vel=p_vec.hi+vel_vec.hi*dt=vel+vel*dt`(无用)
    __m256 result_vec = _mm256_fmadd_ps(vel_vec, dt_vec, p_vec);
  //`4`.使用掩码写回,只更`新粒子`结构中的位置部分,速度部分不变
    _mm256_maskstore_ps(&particles[i].pos_x, mask, result_vec);
  }
}
  //对比的标量版本
void update_particles_scalar(std::vector<Particle>& particles, float delta_time) {
  for (size_t i = 0; i < particles.size() ; ++i) {
    particles[i].pos_x += particles[i].vel_x * delta_time;
    particles[i].pos_y += particles[i].vel_y * delta_time;
    particles[i].pos_z += particles[i].vel_z * delta_time;
  }
}

这段AVX代码,_mm256_fmadd_ps一条指令就完成了8次乘法和8次加法.虽然C#的.NetCore也引入了内联,但你很难保证JIT``编译器能生成同样高效的汇编,更无法像C++这样对数据结构精确的内存对齐,而后者对SIMD性能至关重要.

在性能压榨到极致的领域,C++对硬件的直接控制力是C#的抽象模型无法比拟的.

三,基础架构软件:自己就是平台,岂能依赖他人

C#不能在一个重量级运行时之上构建另一个运行时
系统内核,数据库引擎,浏览器内核,消息队列.这些软件是整个软件世界的基石.它们自己就是平台,为上层应用提供管理内存,任务分发,IO处理.

让它们运行在.Net之上,与让地基建在另一栋楼的屋顶上,既荒谬又低效.
C++直接与系统内核对话,零中间商.

基础架构软件需要最原的系统调用权限.比如,自己实现内存分配器以优化特定场景的内存使用,或直接调用``epoll/IOCP来构建最高效的网络IO模型,绕开所有通用的线程池和分发封装.

看代码,一个高性能``网络服务器如何用C++直接与林操内核的IO机制共舞:

   //一个极简的,基于`Linuxepoll`的`IO`多路复用服务器框架
  //它展示了如何用一个线程管理数千个并发连接
#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <iostream>
#include <vector>
#define MAX_EVENTS 128
void run_server(int port) {
  int server_fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
  //...省略`bind`,`listen`等设置...
  int epoll_fd = epoll_create1(0);
  struct epoll_event event, events[MAX_EVENTS];
  // 将监听socket设置为非阻塞模式 (accept()非阻塞套接字不会阻塞)
   //原代码在socket()中已用SOCK_NONBLOCK完成它
  //fcntl更传统且可移植
  event.events = EPOLLIN;
  event.data.fd = server_fd;
  epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &event);
  std::cout << "Infrastructure server running..." << std::endl;
  while(true) {
  //核心调用:让内核告诉哪些`套接字`准备好了,而不是一个个去问
    int n_events = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
    for (int i = 0; i < n_events ; ++i) {
      if (events[i].data.fd == server_fd) {
  //处理新连接
        int client_fd = accept(server_fd, nullptr, nullptr);
  //...将`client_fd`也注册进`epoll...`
      } else {
  //处理已连接客户的数据读写...
  //直接操作`文描符`,自己管理缓冲...
      }
    }
  }
  close(server_fd);
}

C++可直接调用``epoll_wait,这是与内核最直接的通信方式.C#的async/await虽然好用,但它封装在CLR的线程池和分发器之下,你无法穿透这层封装去实现"零拷贝"或自定义分发策略等极限优化.

构建基础平台,必须使用能直接操作硬件和OS内核的语言.C++是事实上的标准.

四,跨语言核心库:做软件世界的通用零件

如果写一个库,想让Python,Java,Rust,Go,Node.js都能用,C++是当前唯一可靠的选择.无论是OpenCV,TensorFlow还是FFmpeg,它们的核心都是C++,也是全世界的工具.

C++可稳定的,被广泛支持的CABI

C++可用extern"C"导出一组纯C语言风格的函数接口.这背后是C++稳定到几乎刻在石头上的CABI.

相比之下,C#的ABI更像是.NET生态圈内部的"方言",它会随着.Net版本迭代,并且和自身的运行时机制(如GC)深度绑定,做不到C接口那样的"即插即用".

看代码,如何用C++封装一个高性能模块,并提供一个世界通用的C接口:

  //`a_cool_library.cpp``内部实现`,
  //可用上所有`C++20`的酷炫特性
#include <string>
#include <vector>
#include <numeric>
namespace MyCoolLib {
  double calculate_std_dev(const std::vector<double>& data) {
  //...复杂的`内部实现`...
    double sum = std::accumulate(data.begin(), data.end(), 0.0);
    double mean = sum / data.size();
    double sq_sum = std::inner_product(data.begin(), data.end(), data.begin(), 0.0);
    return std::sqrt(sq_sum / data.size() - mean * mean);
  }
}
  //暴露给`外部世界`的C接口
  //`extern"C"`确保`函数名`,不会`C++``编译器`"粉碎",保持简单的C风格命名
extern "C" {
  //使用`__declspec(dllexport)`在`窗口`上导出函数
  __declspec(dllexport) double process_data(const double* data, int size) {
    if (!data || size <= 0) return 0.0;
  //将C风格的数组和大小,转换成安全的`C++`容器
    std::vector<double> vec(data, data + size);
  //调用内部的`C++`实现
    return MyCoolLib::calculate_std_dev(vec);
  }
}

神算的ctypes,Java的JNI,Rust的FFI可轻易调用该process_data函数.而C#的NativeAOT虽然也在努力,但其ABI的复杂性和生态的局限性,让它远未达到C++该"世界语"的地位.

当你的目标是构建一个跨语言,跨平台的底层基础库时,C++的CABI兼容是其不可撼动的护城河.

这4个领域,就是C++的自留地,是它安身立命的根本.