c++11

Move semantics in C++11

After studying an example for Move Semantics of C++11, I write a more complete code snippet:

#include 
using namespace std;
class Intvec {
  public:
    explicit Intvec(size_t num = 0)
      : m_size(num), m_data(new int[m_size]) {
      log("constructor");
    }
    ~Intvec() {
      log("destructor");
      if (m_data) {
        delete[] m_data;
        m_data = 0;
      }
    }
    Intvec(const Intvec& other) : m_size(other.m_size), m_data(new int[m_size]) {
      log("copy constructor");
      for (size_t i = 0; i < m_size; ++i)
        m_data[i] = other.m_data[i];
    }
    Intvec(Intvec&& other) {
      log("move constructor");
      std::swap(m_size, other.m_size);
      std::swap(m_data, other.m_data);
      other.m_size = 0;
      other.m_data = nullptr;
    }
    Intvec& operator=(const Intvec& other) {
      log("copy assignment operator");
      Intvec tmp(other);
      std::swap(m_size, tmp.m_size);
      std::swap(m_data, tmp.m_data);
      return *this;
    }
    Intvec& operator=(Intvec&& other) {
      log("move assignment operator");
      std::swap(m_size, other.m_size);
      std::swap(m_data, other.m_data);
      return *this;
    }
  private:
    void log(const char* msg) {
      cout << "[" << this << "] " << msg << "\n";
    }
    size_t m_size;
    int* m_data;
};
int main(void) {
  Intvec v1(20);
  Intvec v2;
  cout << "assigning lvalue...\n";
  v2 = v1;
  cout << "ended assigning lvalue...\n";
  //Intvec v4 = std::move(Intvec(30));
  Intvec v3;
  cout << "move assigning...\n";
  v3 = Intvec(30);
  cout << "ended move assigning...\n";
  cout << "move constructor\n";
  Intvec v4 = std::move(v3);
  cout << "ended move constructor\n";
  return 0;
}

Pay attention to last two lines in 'move constructor':

...
      other.m_size = 0;
      other.m_data = nullptr;
...

Since 'move constructor' will not set initial value for m_size and m_data of 'v4', the m_size and m_data of 'v3' will be uninitial after swaps. Adding the two lines of code means to initialize m_size and m_data of 'v3'.

Small tips about containers in Intel Threading Building Blocks and C++11

Changing values in container

std::map table;
for (auto item : table) {
  item.second = 2;
}

The code above will not change any value in container ‘table’. ‘auto’ will become std::pair and ‘item’ will be a copy of real item in ‘table’, so modify ‘item’ will not change the actual value in container.
The correct way is:

for (auto &tem : table) {
  item.second = 2;
}

or:

for (std::map::iterator it = table.begin(); it != table.end(); ++it) {
  it->second = 2;
}

Do traversal and modification concurrently in a container
Using concurrent_hash_map like this:

typedef tbb::concurrent_hash_map CacheMap;
CacheMap cache;
....
// Thread 1
for (auto &item : cache) {
  cout << item.second << "\n";
}
// Thread 2
CacheMap::accessor ac;
cache.insert(ac, std::make_pair("hello", 123));
....

will cause the program to coredump.
The reason is that concurrent_hash_map can't be modified and traversed concurrently.
Actually, Intel figure out another solution to concurrently-traverse-and-insert: concurrent_unordered_map.
But still be careful, concurrent_unordered_map support simultaneous traversal and insertion, but not simultaneous traversal and erasure.

Why you should update your gcc (and c++ library)

Consider the code below:

#include 
#include 
#include 
using std::string;
struct string_hashfunc {
    size_t operator()(const string *a) const
    {
        size_t hash = 0;
        if(a == NULL) return 0;
        for (string::const_iterator it = a->begin(); it != a->end(); it++) {
            hash = hash * (*it);
        }
    }
};
typedef __gnu_cxx::hash_map StringHash;
int main(void) {
    StringHash sh;
    string *a = new string("earth");
    string *b = new string("sky");
    sh[a] = b;
    for (StringHash::iterator it = sh.begin(); it != sh.end(); it++) {
        delete it->first;
        delete it->second;
    }
}

It could be compiled and run on CentOS 5 (gcc-4.1.2), but will core dump at runtime.

g++ test.cpp -o test -g2 -O0
./test
Segmentation fault

The gdb stack shows the breakpoint is in string_hashfunc::operator():

(gdb) bt
#0  0x00007ffff7b7c1e3 in std::basic_string, std::allocator >::end() const () from /usr/lib64/libstdc++.so.6
#1  0x0000000000400fd0 in string_hashfunc::operator() (this=0x7fffffffe861, a=0x606620) at test.cpp:12
......

Let’s see the source code of “ext/hash_map” in /usr/include/c++/4.1.2/ext/hashtable.h:

  template 
    _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>&
    _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>::
    operator++()
    {
      const _Node* __old = _M_cur;
      _M_cur = _M_cur->_M_next;
      if (!_M_cur)
    {
      size_type __bucket = _M_ht->_M_bkt_num(__old->_M_val);
      while (!_M_cur && ++__bucket < _M_ht->_M_buckets.size())
        _M_cur = _M_ht->_M_buckets[__bucket];
    }
      return *this;
    }

And in the implementation of _M_bkt_num():

      size_type
      _M_bkt_num_key(const key_type& __key) const
      { return _M_bkt_num_key(__key, _M_buckets.size()); }
      size_type
      _M_bkt_num(const value_type& __obj) const
      { return _M_bkt_num_key(_M_get_key(__obj)); }
      size_type
      _M_bkt_num_key(const key_type& __key, size_t __n) const
      { return _M_hash(__key) % __n; }

It use _M_hash() to compute the bucket number of the key, and the _M_hash() is actually string_hashfunc::operator(). The reason is clear now: the iterator want to increase, so it call operator++() –> _M_bkt_num() –> _M_bkt_num_key() –> _M_hash() –> string_hashfunc::operator() and it can’t fetch the key because it has been freed in “delete it->first”.
How about new g++ and new c++ library? Let’s try to write the same program on CentOS 7 (gcc-4.8.5) and change “ext/hash_map” to “unordered_map” (for c++ 11 standard):

#include 
#include 
#include 
using std::string;
struct string_hashfunc {
    size_t operator()(const string *a) const
    {
        size_t hash = 0;
        if(a == NULL) return 0;
        for (string::const_iterator it = a->begin(); it != a->end(); it++) {
            hash = hash * (*it);
        }
    }
};
typedef std::unordered_map StringHash;
int main(void) {
    StringHash sh;
    string *a = new string("earth");
    string *b = new string("sky");
    sh[a] = b;
    for (StringHash::iterator it = sh.begin(); it != sh.end(); it++) {
        delete it->first;
        delete it->second;
    }
}

Then build it:

g++ test.cpp -o test -g2 -O0 -std=c++11
./test

Everything goes normal because the new implementation of c++ library use “_M_nxt” to point to the next hash node instead of using hash function (could see it in /usr/include/c++/4.8.5/bits/hashtable_policy.h).

Robin on Linux

c++11