小编Tou*_*dou的帖子

为什么 C++ 没有定义/声明函数的关键字？基本上该语言中的所有其他设计抽象都有一个 ( struct, class, concept, module, ...)。

它不会让语言更容易解析，也更一致吗？大多数“现代”语言似乎都这样（fn在 rust、funkotlin 中，......）。

我正在尝试创建一个专门用于某些给定类型的全局函数模板。它看起来像这样：

啊（主模板，模板特化，extern）

template <typename T> void foo() { std::cout << "default stuff" << std::endl; }
template<> void foo<int>() { std::cout << "int stuff" << std::endl; }
extern template void foo<int>();

A.cpp（显式实例化）

template void foo<int>();

乙

void bar();

B.cpp（包括啊）

 void bar() { foo<int>(); }

主程序

foo<int>();
bar();

编译器让我崩溃：“'void foo()' 的多个定义。我认为 extern 应该处理这个问题。B 编译单元不应该实例化 foo，而是在链接时使用 A 实例化，没有? 我哪里错了？

请注意，如果我不专门化 foo，则代码编译得很好。函数特化和实例化之间是否存在某种冲突？

我有多个类（Foo和Bar这里简单）

struct Bar {};
struct Foo {};

和一个采用单个模板参数并根据该类型执行某些操作的函数：

template <typename T>
constexpr void doSomething() { cout << "Am I a Foo? " << is_same<T,Foo>::value << endl; }

在我的代码中，为我提供了Foos和Bars 的模板参数包，并且应该doSomething()在它们的每个参数上调用函数（我不在乎函数的执行顺序）。

doStuff<Foo, Bar, Bar>(); // --> True / False / False

到目前为止，我唯一能想到的解决方案是：

template <typename... Ts>
class Doer;

template <>
struct Doer <> {
    static constexpr void doStuff() {}
};

template <typename Head, typename... Tail>
struct Doer <Head, Tail...> {
    static constexpr void …

我有一个调用一些 NASM 代码的简单 C++ 程序：

主.cpp：

#include <iostream>

extern "C" int foo();

int main() {
  std::cout << "The result is: " << foo() << std::endl;
  return 0;
}

foo.asm：

bits 64
global foo

section .text
foo:
    mov rax, 123
    inc rax
    ret

我可以用 CMake 编译所有东西

cmake_minimum_required (VERSION 3.15)

project (assembly-x64 LANGUAGES CXX ASM_NASM)
  
# old school CMAKE to handle NASM formats
if(WIN32)
    set(CMAKE_ASM_NASM_FLAGS_DEBUG "-g -F cv8")
    set(CMAKE_ASM_NASM_OBJECT_FORMAT win64)
elseif(APPLE)
    set(CMAKE_ASM_NASM_FLAGS_DEBUG "-g -F dwarf")
    set(CMAKE_ASM_NASM_OBJECT_FORMAT macho64)
else()
    set(CMAKE_ASM_NASM_FLAGS_DEBUG "-g -F dwarf") …

我正在尝试使用OVERFLOW-PLOT3D q文件格式（在此定义：http ://overflow.larc.nasa.gov/files/2014/06/Appendix_A.pdf）保存一个解决方案。对于单个网格，基本上是

READ(1) NGRID
READ(1) JD,KD,LD,NQ,NQC
READ(1) REFMACH,ALPHA,REY,TIME,GAMINF,BETA,TINF, &
        IGAM,HTINF,HT1,HT2,RGAS1,RGAS2, &
        FSMACH,TVREF,DTVREF
READ(1) ((((Q(J,K,L,N),J=1,JD),K=1,KD),L=1,LD),N=1,NQ)    

所有变量都是双精度数字，但NGRID，JD，KD，LD，NQ，NQC和IGAM是整数。我需要使用MPI-IO导出解决方案。如果我仅用一个处理器做一个非常简单的示例，以下代码将不起作用，但是我不明白为什么。

call mpi_file_open( mpi_comm_world, fileOut, mpi_mode_wronly + mpi_mode_create, &
                  mpi_info_null, mpi_fh, ierr )
offset = 0
call mpi_file_seek( mpi_fh, offset, mpi_seek_set, ierr )
call mpi_file_write( mpi_fh, (/NGRID,JD,KD,LD,NQ,NQC/), 6, mpi_integer, mstat, ierr )
call mpi_file_write( mpi_fh, (/REFMACH,ALPHA,REY,TIME,GAMINF,BETA,TINF/), 7, mpi_double_precision, mstat, ierr )
call mpi_file_write( mpi_fh, IGAM, 1, mpi_integer, mstat, ierr )
call mpi_file_write( mpi_fh, (/HTINF,HT1,HT2,RGAS1,RGAS2,FSMACH,TVREF,DTVREF/), 8, mpi_double_precision, mstat, ierr )

call mpi_file_write( mpi_fh, Q, NQ*JD*KD*LD, …

是否可以T从 a 创建堆栈变量（具有移动构造函数的类型）std::unique_ptr<T>？

我尝试过类似的东西

std::unique_ptr<T> p = ext_get_my_pointer();   // external call returns a smart pointer
T val{std::move(*p.release())};                // I actually need a stack variable

但它看起来很难看，并且显然会造成内存泄漏。但不知道为什么。

我有一个随机访问迭代器，我需要把它变成一个指针（外部 API 需要它！）。我可以做T* ptr = &(*iter);，但我觉得它很丑。有没有更好的办法？所有随机访问迭代器通常都实现->运算符，但我不知道获取指向数据的指针的通用方法。