ちょっと必要になったので、書いてみました。 vector中のbefore番目にある要素を、after番目に移動します。 #include <vector> #include <utility> // 要素の位置を移動させる template <class T> void move_position(std::vector<T>& v, std::size_t before, std::size_t after) { T x = std::move(v[before]); v.erase(v.begin() + before); v.insert(v.begin() + after, std::move(x)); } #include <boost/detail/lightweight_test.hpp> #include <boost/range/algorithm/equal.hpp>

<string>ヘッダにあるstd::getline()関数は、行単位の読み取りだけでなく、区切り文字を指定するバージョンもあるので、splitの実装に使えたりする。 #include <iostream> #include <string> #include <sstream> #include <vector> std::vector<std::string> split(const std::string& input, char delimiter) { std::istringstream stream(input); std::string field; std::vector<std::string> result; while (std::getline(stream, field, delimiter)) { result.push_back(field); } retu

C++0x では、各コンテナに emplace/emplace_back/emplace_front/emplace_hint というメンバ関数が追加されます。 こういうクラスがあった場合 struct something { something(int, int, int); }; something をコンテナの要素として追加する場合、 C++03 では以下のようにしていました。 vector<something> v; v.push_back(something(1, 2, 3)); この方法では、 something のコンストラクタによる一時オブジェクトの生成と、コピーのコストが発生します。 Placement Insert では、可変引数テンプレートによって要素型のコンストラクタ引数を受け取ることで 要素をコンテナ内で一度だけ生成し、コピーのコストをなくします。 vector<

C++0x で追加される STL アルゴリズム ・find_if_not find_if の逆． pred(*i) == false のイテレータを返す template<class InputIterator, class Predicate> inline InputIterator find_if_not(InputIterator first, InputIterator last, Predicate pred) { while (first != last && pred(*first)) ++first; return first; } #include <vector> #include <algorithm> using namespace std; // 偶数？ bool is_even(int value) { return value % 2 == 0; } int

C++0x では、 unordered_map と unordered_set という連想コンテナが追加されます。 (unordered_multimap, unordered_multiset もあります) map と set は二分木を使用した連想コンテナですが unordered_map と unordered_set はハッシュ表を使用した連想コンテナです。 namespace std { // <unordered_map> template <class Key, class T, class Hash = hash<Key>, class Pred = std::equal_to<Key>, class Alloc = std::allocator<std::pair<const Key, T> > > class unordered_map; // <unordered_s

マルチスレッドアプリケーションでは、スレッドごとに一意なデータを保持する必要が起きます。 これを、スレッドローカル記憶域と呼びます。 C++0x では、これを言語でサポートするため、 thread_local というキーワードが追加され thread_local を付けて宣言された変数は、スレッドごとに一度だけインスタンス化されます。 #include <threads> thread_local int j = 42; void foo() { j = 43; } int main() { std::thread t(foo); t.join(); if(j != 42) abort(); } 【スレッド変数のアドレス】 &演算子は、スレッド変数に使用された場合、現在のスレッドの変数のアドレスを返します。 なので、スレッド変数のアドレスは定数ではありません。 スレッドローカル記憶域は、ア

union のメンバに対する制限が(とくに制限する理由もなかったので)解除され、 参照以外の全ての型を持つことができるようになる union U { int i; float f; std::string s; // 今まではできなかった }; 今まではこの制限のためにテンプレートやキャストを使っていたが 今回の変更で union がより強力でより便利になる 注意事項 ・参照型をメンバにすることはできない ・静的メンバを持つことができる ・メンバ関数を持つことはできるが、仮想関数を持つことはできない ・基本クラスを持ってはならない ・基本クラスとして使用されてはならない ・ある共用体のメンバ、もしくはあるクラス内の匿名共用体のメンバに対して non-trivial な特殊メンバ関数が定義された場合、その特殊メンバ関数は その共用体またはクラスに対して、 deleted 定義される ・暗黙に

スマートポインタのようなクラスを作成する場合、if文でヌルポインタかどうか判定できるようにするために operator boolをオーバーロードします。 template <class T> class smart_ptr { T* p_; public: operator bool() const { return p_ != 0; } }; smart_ptr<int> p; // OK if (p) { // ポインタは有効 } else { // ポインタは無効 } しかし、この方法では以下のような意味のないコードもコンパイルが通ってしまいます。 float f = p; int x = p + 1; cout << p << endl; C++03には、この問題を解決するために"conversion to unspecified bool"というイディオムがあります。 これを使用

キャスト演算子(operator T)の先頭にexplicitを付けることによって 暗黙のキャストを防ぐことができるようになる class Y {}; struct Z { explicit operator Y() const; // ... }; void h(Z z) { Y y1(z); // OK Y y2 = z; // エラー！ Y y3 = (Y)z; // OK } C++0x言語拡張まとめ

コンパイラが生成する関数(コンストラクタ, コピーコンストラクタ, 代入演算子, デストラクタ etc...) のdefault/delete指定ができるようになる struct hoge { hoge() = default; // コンパイラが生成するデフォルトコンストラクタを使う }; インライン化の制御 struct hoge { virtual ~hoge(); }; hoge::~hoge() = default; // インライン化させない コピーの制御 struct hoge { hoge() = default; hoge(const hoge&) = delete; hoge& operator=(const hoge&) = delete; }; hoge h; // OK hoge h2(h); // エラー h = h2; // エラー new演算子の制御 str

C++03 では、右辺値に対して左辺値用のメンバ関数を呼べてしまいます。 class X { public: X& operator=(const X&) { ... } }; int main() { X x; X() = x; // エラーになるべきだが、コンパイルが通ってしまう } この問題を解決するため、 C++0x ではメンバ関数を & 、 && で修飾することができるようになり、そのオブジェクトが左辺値の場合だけ呼べる関数、右辺値の場合だけ呼べる関数を判別できるようになります。 class X { public: X& operator=(const X&) & // 左辺値修飾 { ... } }; int main() { X x; X() = x; // エラー！ } また、オブジェクトが左辺値なのか右辺値なのかでメンバ関数をオーバーロードできるので、 左辺値だったらco

優先順位付きでoperator<()を定義するにはどうすればいいでしょうか。 Windowsのエクスプローラで言うところの、「ファイル種別順に並べて、同じファイル種別のものはファイル名順に並べる」というようなものです。 これは、std::tupleのoperator<()をそのまま使えばできます。クラスのメンバ変数をタプル化してstd::tupleの比較演算子を使います。 #include <iostream> #include <string> #include <vector> #include <algorithm> #include <tuple> struct File { std::string type; std::string name; File(const std::string& type, const std::string& name) : type(type),