有没有一种方法可以boost::combine使用结构化绑定和基于范围的 for（这样结构绑定中的标识符实际上指向容器的元素，而不是内部使用的嵌套元组boost::combine）？以下（实时示例）无法编译：
#include <boost/range/combine.hpp>
#include <iostream>
int main()
{
std::vector<int> a{1,2,3};
std::vector<int> b{2,3,4};
for (auto [f, s] : boost::combine(a, b))
{
std::cout << f << ' ' << s << std::endl
}
}
如果我有std::map<X, Blah>,使用实例查找地图中匹配项目的最佳方法是Y什么？
假设信息Y足以唯一地找到X,但出于性能原因,我不想X通过复制Y值来创建实例.
我知道我可以创建一个公共基类或接口做到这一点X,并Y和制作该地图的关键,但有没有其他办法？例如,创建某种比较对象？
以下是示例代码:
class X
{
public:
int id;
int subId;
};
std::map<X, Details> detailsMap;
class Y
{
public:
int getId();
int getSubId();
int someOtherUnrelatedThings1;
int someOtherUnrelatedThings2;
};
现在,如果我有一个实例Y,原则上我应该能够在我的地图中找到匹配的项目,因为我可以得到一个id和subId一对.但我能做到这一点,而无需创建的实例X在和复制id和subId？
我想编写一个辅助函数,如:
template <typename F, typename Range1, typename Range2>
auto helper(const Range1& left, const Range2& right, F&& pred)
{
using namespace std; // for cbegin/cend and ADL
return pred(cbegin(left), cend(left), cbegin(right), cend(right));
}
它适用于容器:
std::vector<int> v1 = {1,2,3,4,5,6};
std::vector<int> v2 = {5,4,3,2,1,6};
std::cout << helper(v1, v2, [](const auto&... args){ return std::is_permutation(args...);}) << std::endl;
但它没有推断initializer_list--s(例子):
std::cout << helper({1,2,3,4,5,6}, {5,4,3,2,1,6}, [](const auto&... args){ return std::is_permutation(args...);}) << std::endl;
是否有一种惯用的重写方式,helper以便它推导出容器和initializer_list-s？
对于容器和容器的所有组合,initializer_list我无法想出任何比重载更好的东西.
在以下示例中,gcc 7发出警告:
"B"的默认移动分配称为虚拟基础'A'的非平凡移动赋值运算符[-Wvirtual-move-assign]
如果我创建一个std::tuple<B>对象.Clang 5没有报告任何问题.如果vector被删除,问题就会消失Base.例子.
#include <tuple>
#include <vector>
class Base
{
public:
virtual ~Base();
std::vector<int> v;
};
class A : public Base
{
};
class B : public virtual A
{
};
int main()
{
B *b = new B;
B another{*b}; // <<<--- this compiles
std::tuple<B> t; // <<<--- gives warning
}
为什么会出现std::tuple(并且没有移动分配),如果我需要保持这样的层次结构,那么解决它的正确方法是什么？
我试图在linux下用Python打开一个原始套接字.
我的简单代码:
s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_IP)
s.bind((HOST, 5454))
我收到了这个错误:
[ERROR] Protocol not supported
顺便说一句,我在linux 12.04下使用python 2.7.3,我用root来运行代码.
有人有线索吗？
更新:我的灵魂,dstromberg给出的解决方案是正确的.如果您想要所有数据包,请使用他的解决方案.但是,还有另一种组合,
s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
也有效.
在这种情况下,您将收到所有带有IP和TCP标头的TCP数据包.如果您使用dstromberg的解决方案,您还将看到以太网标头.所以它取决于你想要你的数据包的'原始'~~
当我从函数中返回a时std::lock_guard,std::pair我会得到可怕的错误.但是当我将它打包成一个类时,我没有任何问题(编译并按预期工作).我不明白为什么.细节如下:
我设计了一个小模板类,以便方便地锁定和解锁共享对象.它不是特别创新,但C++ 17允许它非常紧凑并且代码读/写友好:
template <typename T> class Locked {
public:
Locked(T& _object, std::mutex& _mutex)
: object(_object)
, lock(_mutex)
{
}
T& object;
std::lock_guard<std::mutex> lock;
};
template <typename T> class Lockable {
public:
Locked<T> borrow() { return Locked(object, mutex); }
Locked<const T> borrow() const { return Locked(object, mutex); }
private:
T object;
mutable std::mutex mutex;
};
它可以像:
int main()
{
Lockable<std::vector<int>> lv;
auto [vec, lock] = lv.borrow();
std::cout << vec.size() << std::endl;
}
我的问题是这个.这Locked堂课很瘦.我以为我可以使用std::pair …
我发现"如何在其声明之外定义模板类的朋友模板函数"(SO/cppreference),但是如果我们在混合中添加另一个内部非模板类,该怎么做呢？
即如何(外部)定义operator<<声明的in class Internal以下示例:
#include <iostream>
template <typename T>
class External {
public:
explicit External(T initial) : value{initial} {}
class Internal {
public:
Internal(const External& e) : internal_value{e.value} {}
private:
friend std::ostream& operator<<(std::ostream& os, const Internal& i);
// ^^^ this one
/* body
{
return os << i.internal_value;
}
*/
T internal_value;
};
friend std::ostream& operator<<(std::ostream& os, const External& e)
{
return os << Internal{e};
}
private:
T value;
};
int main()
{ …可以创建一个str(a)将使用其argument(a)及其字符串化名称(#a)的宏,例如:
#include <iostream>
#define str(a) #a, " ", a
int main()
{
int i = 5;
float f = 4.5;
const char* s = "string";
auto l = [] (const auto&... p) { (std::cout << ... << p) << std::endl; };
l(str(i));
l(str(f));
l(str(s));
}
例子.
是否有一种简单的方法来打印带有每个参数名称的可变数量的参数？即PREPEND_EACH_ARG_WITH_HASH_ARG从以下实施:
#include <iostream>
#include <tuple>
template <typename ... Ts>
void print_all(const Ts&... ts)
{
(std::cout << ... << ts) << std::endl;
}
#define …使用gcc 6.3编译时，此示例程序
#include <array>
class alignas(4096) A {
std::array<int, 256> array;
};
int main()
{
A a;
}
给出以下警告：
3 : <source>:3:21: warning: requested alignment 4096 is larger than 128 [-Wattributes]
class alignas(4096) A {
^
但是，gcc 7.2没有这种错误。
如果我将一个向量分配或复制到另一个向量(具有与前者相同或更大的容量),我可以假设后者的缓冲区将被重用吗？
以下示例说明我可以通过标准保证吗？这方面的行为std::vector::assign和std::vector::operator=这方面有什么区别吗？
#include <vector>
#include <iostream>
#include <cassert>
int main()
{
std::vector a {1, 2, 3, 4, 5};
std::vector b {1, 2, 3, 4};
std::vector c {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::cout << "1 ==== " << a.capacity() << " " << a.data() << std::endl;
const auto* pa = a.data();
a = b;
assert(pa == a.data());
std::cout << "2 ==== " << a.capacity() << " " << a.data() << std::endl;
a …