相关疑难解决方法(0)

我正在尝试存储std::tuple不同数量的值,这些值稍后将用作调用与存储类型匹配的函数指针的参数.

我创建了一个简化的示例,显示了我正在努力解决的问题:

#include <iostream>
#include <tuple>

void f(int a, double b, void* c) {
  std::cout << a << ":" << b << ":" << c << std::endl;
}

template <typename ...Args>
struct save_it_for_later {
  std::tuple<Args...> params;
  void (*func)(Args...);

  void delayed_dispatch() {
     // How can I "unpack" params to call func?
     func(std::get<0>(params), std::get<1>(params), std::get<2>(params));
     // But I *really* don't want to write 20 versions of dispatch so I'd rather 
     // write something like:
     func(params...); // Not legal
  }
}; …

C ++ 11引入emplace了在序列内部就位构造元素的功能。这是对insert元素进行复制或移动的补充。

但是，在的多个重载中insert，只有单个元素插入版本，

即

iterator insert( const_iterator p, T const& x);
iterator insert( const_iterator p, T&& x );

有一个emplace版本，

template< class... Args > 
iterator emplace(const_iterator p, Args&&... x);

是否有任何理由不允许n使用来就地构建元素emplace？

虽然像

template< class... Args > 
iterator emplace(const_iterator p,size_type n,Args&&... x);

就像相应的 insert

iterator insert(const_iterator p,size_type n,const_reference x);

可能会与其他重载冲突，将构造函数参数用作tuple，或使用一些特殊标记（例如in_place_t可能会消除歧义）。

编辑 建议的功能emplace_n对于vector可能像下面给出的一个行为

template<class... Args>
iterator emplace_n(const_iterator p,size_type n,Args&&... x)
{
    size_type const …

在通用代码中，我试图告诉输出迭代器（实际上 astd::back_inserter_iterator移动一系列元素。令我惊讶的是，它看起来好像元素在 move-to-back_inserter 操作中移动。

#include<algorithm> // move
#include<iterator> // back_inserter
#include<vector>
int main(){
    std::vector<std::vector<double> > v(10, std::vector<double>(100));
    std::vector<std::vector<double> > w;

    assert( not v[0].empty() and w.size() == 0 );
    std::copy(v.begin(), v.end(), std::back_inserter(w));
    assert( not v[0].empty() and w.size() == 10 );

    std::move(v.begin(), v.end(), std::back_inserter(w));
    assert( v[0].empty() and w.size() == 20 ); // were v elements moved to w?
}

但是，我认为 的元素不可能v真正移动到w，因为毕竟back_inserter会执行 apush_back这意味着复制到w。

在这种std::move情况下，v元素似乎更有可能被移动到临时文件中，然后才复制到w.

那是对的吗？真的有 …

我正面临一个问题。从 lambda 函数返回 std::pair<T1, T2>。我试图用打开的 ifstream 生成地图，但编译器抱怨这个输出：

/usr/include/c++/9/bits/stl_algo.h:4337:12: 错误：使用已删除的函数 'std::pair<const std::__cxx11::basic_string, std::basic_ifstream >& std::pair <const std::__cxx11::basic_string, std::basic_ifstream >::operator=(const std::pair<const std::__cxx11::basic_string, std::basic_ifstream >&)'

我为 std::pair 浏览了 cppref，但我没有注意到 copy operator= 对这个不可行。

我相当肯定返回对的 lambdas 是可能的，那么我在下面的代码段中肯定有一些误解。

std::map<int, std::string> mFileMap;
std::map<std::string, std::ifstream> files;
std::transform(mFileMap.begin(), mFileMap.end(), files.begin(),
                [](const auto& arg) -> std::pair<std::string, std::ifstream> {
                    std::string path(arg.second);
                    std::ifstream stream(path);
                    return std::make_pair(path, stream);
                });