小编J. *_*rez的帖子

背景

我正在使用MPI进行高性能计算中的C ++项目。我有一个函数，其中包含一些不同的重载，可用于将不同的类型转换为字符串：

void append(std::string& s, int value);
void append(std::string& s, void* value);
void append(std::string& s, MPI_Request request); 

当我使用Open MPI时，这工作正常。在OpenMPI中，MPI_Request是的别名ompi_request_t*，因此每个重载都有不同的签名。

但是，最近，我尝试使用MPICH编译代码。在MPICH中，MPI_Request是的别名int，结果是上述代码由于两次append定义而无法编译int：

/home/me/NimbleSM/src/mpi-buckets/src/mpi_err.hpp: At global scope:
/home/me/NimbleSM/src/mpi-buckets/src/mpi_err.hpp:28:6: error: redefinition of ‘void append(std::__cxx11::string&, int)’
 void append(std::string& s, int i) { s.append(std::to_string(i)); }
      ^~~
/home/me/NimbleSM/src/mpi-buckets/src/mpi_err.hpp:17:6: note: ‘void append(std::__cxx11::string&, MPI_Request)’ previously defined here
 void append(std::string& s, MPI_Request request)

题

我应该如何编写append(std::string&, MPI_Request)，以使编译器在MPI_Request定义为时忽略它int，而在MPI_Request是库类型时识别它？

尝试的解决方案：enable_if失败 …

我想编写一个行为几乎等同于 Python 字典的 C++ 对象。C++std::map和std::unordered_mapPython 字典已经具备的一些功能，但缺乏最重要的功能之一，即能够添加任意对象和类型。即使不可能，您离实现 Python 字典的功能还有多远？

之前的一些问题（此处和此处）无法处理向字典添加多种类型的问题。

例如，我希望能够在 C++ 中做这样的事情：

my_dict = {'first': 1,
           'second': "string",
           'third': 3.5,
           'fourth': my_object}
my_dict['fifth'] = list([1, 2, 3])

我能想到的最好的解决方案是使用void指向重新解释的数据的指针，或者某种具有某些类型限制的运行时多态性？

在最简单的示例中，假设我有一个启动线程的函数，该函数依次将局部变量的值设置为true。我们加入线程，然后离开函数。

bool func() {
    bool b = false;
    std::thread t([&]() { b = true; }); 
    t.join();
    return b;
}

该函数将返回true，还是行为未定义？

这里这个问题表明，std::atomic<T>被普遍认为有大小相同T，而事实上，这似乎是对GCC，铛，和MSVC在x86，x64和ARM的情况。

在std::atomic<T>某个类型始终无锁的实现中T，是否保证其内存布局与的内存布局相同T？是否还有其他特殊要求std::atomic，例如对齐？

背景。在我的一堂课中，我们一直在探索Parser单子。Parser通常将monad定义为

newtype Parser a = Parser (String -> [(a, String)])

或作为

newtype Parser a = Parser (String -> Maybe (a, String))

无论哪种情况，我们都可以Parser作为在两种情况下都可以Functor使用的使用代码实例化：

instance Functor Parser where
  fmap f (Parser p) = Parser (fmap applyF . p)
    where applyF (result, s) = (f result, s)

如果我们有一个Parser建回报Maybe (a, String)，这适用f于result如果result存在。如果我们有一个Parserreturn 的构建体[(a, String)]，则这适用于列表中返回的f每个result。

我们可以例如Applicative，Monad …

C++20 引入了协程，可以用来创建生成器和其他类似的东西：

generator<int> counter(int max) {
    for(int i = 0; i < max; i++) {
        co_yield i;
    }
}

有什么方法可以创建一个协程，以便调用者可以提供一个响应，该响应co_yield在协程恢复后返回？让我们称其为 achannel而不是生成器。

这是我希望能够做的一个例子：

channel<int, int> accumulator(int initial) {
    while(true) {
        // Can channel be written so co_yield provides a response?
        int response = co_yield initial;
        initial += response;
    }
}

在这里，每当调用者恢复协程时，它都会提供一个值，co_yield一旦协程恢复，该值就会返回，如下所示：

std::vector<int> accumulate(std::vector<int> values) {
    channel<int, int> acc = accumulator(0);

    std::vector<int> summed_values;

    for(int v : values) {
        // Get whatever value was yielded by the …

代码是这样的:

auto add(auto a, auto b) { return a + b; }

违反ISO c ++ 14标准？该标准的未来版本是否允许代码编写？

我尝试将库从linux移植到win32，有一个结构定义为：

struct X {
    unsigned int    type : 4;
    unsigned int    tag : 4;
}__attribute__((packed));

大小应为1，我将其更改为：

#pragma pack(push, 1)
struct X {
    unsigned int    type : 4;
    unsigned int    tag : 4;
};
#pragma pack(pop)

但是sizeof（X）仍然是4，编码会混乱，如何将大小更改为1？

是否可以使用GCC编译具有特定编译器标志的代码文件的一部分？例如，假设我有一些正在测试的功能。我希望这些功能严格遵守标准，因此我想使用--pedantic标志对其进行编译。但是进行测试的代码在编译时会发出很多警告。有没有办法用--pedantic编译那些特定功能？

另外，假设我有一个精心编写但非常昂贵的函数，需要尽快运行。如何使用-Ofast编译该函数（以及其他一些函数），并使用-O2或-O3编译程序的其余部分？

如何编写一个通用函数run，该通用函数接受某个monad转换器的对象，然后调用相应的函数？

鉴于run s，

• 如果s是StateT，run = runStateT
• 如果s是ReaderT，run = runReaderT
• 如果s是MaybeT，run = runMaybeT

我试着创建一个typeclass Runnable：

:set -XMultiParamTypeClasses
:set -XFlexibleInstances

class Runnable a b where
  run :: a -> b
  (//) :: a -> b
  (//) = run

instance Runnable (StateT s m a) (s -> m (a, s)) where
 run = runStateT

instance Runnable (ReaderT r m a) (r -> m …

假设我定义了一个结构:

struct intpair
{
    int i1;
    int i2;
    /*Other non-virtual members can go here*/
};

是否sizeof(intpair)受c ++标准的保证2*sizeof(int)？如果不能保证,是否有任何编译器或情况不适用？

这段代码是否根据C++标准定义良好？看起来有点哈哈.

#include <string>
char* GetPointer(std::string& s)
{
    return &s[0];
}

标准是否确保该代码返回指向存储字符的数组中第一个元素的指针？