小编Bom*_*maz的帖子

我想用一个INSERT查询插入多行,例如:

INSERT INTO tmp(col_a,col_b) VALUES('a1','b1'),('a2','b2')...

有没有办法轻松地做到这一点,最好是这样的对象数组:

[{col_a:'a1',col_b:'b1'},{col_a:'a2',col_b:'b2'}]

我可能最终在一个块中有500条记录,因此运行多个查询是不可取的.

到目前为止,我只能为一个对象做到这一点:

INSERT INTO tmp(col_a,col_b) VALUES(${col_a},${col_b})

作为一个附带问题:使用${}符号的插入是否可以防止SQL注入？

以下代码无法编译

namespace A {
using C = std::vector<std::string>;
std::ostream& operator << (std::ostream& lhs, const C& rhs) {
    lhs << 5;
    return lhs;
}
}
int main()
{
    A::C f;
    std::cout << f;
    return 0;
}

有错误

Error   C2679   binary '<<': no operator found which takes a right-hand operand of type 'A::C' (or there is no acceptable conversion)   

显然,它无法找到<<运算符,大概是因为将C视为std命名空间中的一个类.有没有办法确保编译器找到此运算符或以其他方式解决问题？

我有一个std::variant我想要转换为另一个std::variant具有超类型的集合.有没有一种方法可以让我简单地将一个分配给另一个？

template <typename ToVariant, typename FromVariant>
ToVariant ConvertVariant(const FromVariant& from) {
    ToVariant to = std::visit([](auto&& arg) -> ToVariant {return arg ; }, from);
    return to;
}

int main()
{
    std::variant<int , double> a;
    a = 5;
    std::variant <std::string, double, int> b;
    b = ConvertVariant<decltype(b),decltype(a)>(a);
    return 0;
}

我希望能够简单地编写b = a以进行转换,而不是通过这个复杂的转换设置.不污染std命名空间.

编辑:只需写入就会b = a出现以下错误:

error C2679: binary '=': no operator found which takes a right-hand operand of type 'std::variant<int,double>' (or there …

我不小心喂默认initializeable struct来std::numeric_limits<somestruct>::infinity().我得到的是一个默认结构.

为什么标准允许这个编译并返回这样一个意外的值？

#include <iostream>

struct somestruct {
    uint64_t a = 7;
};

inline ::std::ostream& operator <<(::std::ostream& s, const somestruct& q) {
    s << q.a;
    return s;
}

int main(int argc, char **argv) {
    constexpr const auto inf = ::std::numeric_limits<somestruct>::infinity();
    std::cout << inf << std::endl;
    return 0;
}

Godbolt用于编译验证

我在一个应该引发异常的子进程中执行代码.

当从子进程返回异常时(我最好在保留堆栈跟踪的同时),我想在主进程中引发相同的异常,但我不知道如何做到这一点.

我从子进程捕获stderr就好了,但我找不到如何解析它,所以我得到了异常的类型.我怎么做到这一点？

我正在使用python 2.7

主要方法

import subprocess

example=subprocess.Popen(["python","example.py"],
                                    stdout = subprocess.PIPE,
                                    stderr = subprocess.PIPE)
return_obj, return_error = example.communicate()

if return_error:
# replace with error from subprocess
  print "Should raise ",NameError('HiThere')
  raise TypeError('Wrong type')

子

raise NameError('HiThere')

我需要打印一个类的名称，例如

template<typename... Args>
struct S{};

使用typeid(S<int,std::vector<double>>).name()其相当简单的方法来打印具有代表性的内容。使用boost demangle甚至可以在gcc上读取。

有什么方法可以获取名称，因此不同的编译器之间的名称相同吗？

我有一个结构,我想使用初始化列表初始化

struct Parent{};

struct Child : private Parent {
    int b;
};

int main() {
    Child c{ 1 };
    return 0;
}

看看其他问题,我发现这个答案表明它应该可以在c ++ 17中使用.

但是,当我尝试上面的片段时,VS2017我得到了

Error   C2440   'initializing': cannot convert from 'initializer list' to 'child'

有没有办法利用这个新功能？

我想制作一个模板，它接受一组模板并使用相同的参数包实例化它们。

不幸的是，我似乎无法弄清楚如何在模板参数包中扩展参数包。

我怎样才能使这个编译？

#include<type_traits>
#include <tuple>

template <template <typename...> typename... Args>
struct TupleTupleMaker
{
    template <typename... InstantiateWith>
    using NewTupleTuple = typename std::tuple<Args<InstantiateWith...>...>;
};

template<typename a, typename b>
using tuple1 = std::tuple<int,a,b>;

template<typename a, typename b>
using tuple2 = std::tuple<a,b,b>;

using expected = std::tuple<
    std::tuple<int,int,double>,
    std::tuple<int,double,double>>;

using actual = TupleTupleMaker<tuple1,tuple2>::NewTupleTuple<int,double>;

static_assert(std::is_same_v<actual,expected>, "Should be same");

我有一个带有虚函数的空基类。有什么办法可以避免手动实现Derived的构造函数以便对其进行初始化？

struct Base
{
    virtual int f(int) const = 0;
    virtual ~Base() = 0; 
};

Base::~Base() {}

struct Derived: public Base
{
    int v;

    int f(int) const override{ return v;};
};

int main() 
{
    return Derived{5}.f(3);
}

我有一个声明，我尝试将日志（字符串）连接在一起形成一个字符串。

像这样的东西

ContainerLog
| where conditions
| summarize strcat(LogEntry) 

但是我无法弄清楚如何连接这样的字符串，因为 strcat 不是聚合函数。我还需要别的东西，但不知道是什么。

我怎样才能做到这一点？

例如，如果我有日志条目“1”、“2”、“3”，则最终结果应该是“123”