小编jha*_*a-G的帖子

我试图做emplace_back一个std::vector<std::map<int, int>>,但找不到正确的语法来做到这一点.

#include<map>
#include<vector>

int main()
{
    std::vector<std::map<int, int>> v;
    std::map<int,int> a {{1,2}};

    v.push_back({{1,2}});

    v.emplace_back({1,2});    // error
    v.emplace_back({{1,2}});  // error
    v.emplace_back(({1,2}));  // error
}

push_back在这里工作,但不是emplace_back.我怎样才能emplace_back工作？

我有一个复制和移动ctor删除的课程.

struct A
{
    A(int a):data(a){}
    ~A(){ std::cout << "~A()" << this << " : " << data << std::endl; }

    A(A const &obj) = delete;
    A(A &&obj) = delete;

    friend std::ostream & operator << ( std::ostream & out , A const & obj);

    int data;
};

我想用这个类的对象创建一个元组.但以下不编译:

auto p = std::tuple<A,A>(A{10},A{20}); 

在另一方面,下面做编译,但给出了一个惊人的输出.

int main() {
    auto q = std::tuple<A&&,A&&>(A{100},A{200});
    std::cout << "q created\n";
}

产量

~A()0x22fe10 : 100
~A()0x22fe30 : 200
q created

这意味着一旦元组构造线结束,就会调用对象的dtor.那么,被毁物体元组的意义何在？

以下代码片段提供了非常奇怪的输出.我期待溢出(Python给出一个MemoryError)

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> a{1,2,3};

    for( auto const & item : a)
        a.push_back(item);


    for( auto const & item : a)
        std::cout<<item<<',';

    return 0;
}

产量:1,2,3,1,0,3,

我该如何解释这个结果？

如果你在Python中做类似的事情,它会给出内存错误.

>>> a = range(0,20)
>>> for i in a:
    a.append(i)



Traceback (most recent call last):
  File "<pyshell#3>", line 2, in <module>
    a.append(i)
MemoryError

>>> 

我想到了这个问题,因为上面编写代码的方式被认为是绑定安全的.并且对于绑定的安全容器不应该在生长/收缩期间foreach type iteration.所以,这是一个漏洞的抽象.

有没有办法可以包装这个foreach循环,以便在循环体中不允许任何导致大小修改/重新分配的操作.

我正在学习这个,这是为了理解类的属性.但与以下代码片段的输出混淆.

class A:
    aliases = None
    name = None

    def __init__(self,name):
        self.name = name
        self.aliases = set([name])

    def add_aliases(self,a):
        self.aliases.add(a)

    def __repr__(self):
        return str(self.name) + str(self.aliases)

arr = []
for i in range(3):
    arr.append(A(i))
    arr[-1].add_aliases(i+1)

for item in arr:
    print item

A.aliases = set([]) ##Modify the static element of class
for item in arr:
    print item  

Python解释器:2.7.9

输出是

0set([0, 1])
1set([1, 2])
2set([2, 3])
0set([0, 1])
1set([1, 2])
2set([2, 3])

我期待这样的东西作为输出.

0set([2, 3])
1set([2, 3])
2set([2, …

http://en.cppreference.com/w/cpp/container/vector/vector列出了所有向量。但是以下两个构造函数会导致编译问题。通常，在呼叫一个的过程中，我们会结束呼叫另一个。

vector( size_type count,
                 const T& value,
                 const Allocator& alloc = Allocator());
vector( std::initializer_list<T> init,
        const Allocator& alloc = Allocator() );

通常归结为将 {} 更改为 () 或反之亦然，以使事情正常进行。

有没有办法让ctor的选择变得清晰？不用担心括号。

PS-如果你放了正确的括号，下面的代码就可以完美工作。

vector{elem1, elem2}; // Initializer list version
vector(vector_size, elem); // A vector of size `vector_size` all the items having value = elem

在python中我们可以将两个变量交换为

>>> a , b = b , a

我们可以在C++ 11中进行类似的交换

void swap(int &a,int &b)
{
    std::tie(a,b) = std::make_tuple(b,a);
}

以上工作正常,在O3生成类似的装配

void swap(int &a,int &b)
{
    int c = a;
    a = b;
    b = c;
}

但我的问题是它符合标准还是我遗漏了什么？或者像侥幸......

a = (a+b) - (b=a);

哪个有序列点问题.

可以将ASCII文本(不能将其称为字符串)分配给enum值,如下所示:

#include <iostream>
// Macro to handle BIG/LITTLE ENDIAN
// Endianness is suppoesed to handled in this macro
#define TEMP(X) X

enum t
{
    XX = 'AA', // 0x4141  or  0100 0001 0100 0001
};

int main()
{
    std::cout<<XX<<std::endl;
}

0x4141在这种情况下,编译器会编译它并在编译时生成一个Hexa-decimal常量.它确实生成一个编译警告:

main.cpp:9:14: warning: multi-character character constant [-Wmultichar]
     XX = 'AA', // 0x4141  or  0100 0001 0100 0001

我的问题是,我们可以避免这种警告吗？

或者我们可以编写一个更优雅的代码来实现类似的结果,可能使用模板和constexpr？

我正在寻找一种便携式替代方案,这样我就可以在不影响核心逻辑的情况下将其作为重构的一部分.

我试图将回调函数作为函数参数传递.但是在以下代码中获取模板替换失败错误.不确定为什么模板替换失败.

#include<iostream>
#include <map>
#include <tuple>
#include <functional>

template<typename A,typename B>
void myfun(std::map<A,B> & mm, std::function<std::tuple<A,B>(void)> fn)
{
    A key;
    B val;
    std::tie(key,val) = fn();
    mm[key] = val;
}

std::tuple<std::string,int> fun()
{
    return std::make_tuple(std::string("hi"),1);
}

int main()
{
    std::map<std::string,int> gg;
#if 0
        //fixed version
        std::function<std::tuple<std::string,int>(void)> yy = fun;//fixed
        myfun(gg,yy);//fixed
#else
        // error causing code
        myfun(gg,fun);
#endif
}

错误如下

main.cpp:8:6: note:   template argument deduction/substitution failed:

main.cpp:25:17: note:   mismatched types 'std::function<std::tuple<_T1, _T2>()>' and 'std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int> (*)()'

     myfun(gg,fun);