C++ モダンな書き方

#include <vector>

void func() {

    // 右辺値 下のvectorのような式を抜けるとデストラクタが呼ばれるオブジェクト
    int i = (std::vector<int>{1,2,3}).pop();

    // 左辺値 式を抜けてもデストラクタが呼ばれないオブジェクト
    {
        std::vector<int> v;
        v.push_back(1);
        v.push_back(2);
    }
}

#include <vector>

std::vector<int> func() {    
    std::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    
    return v;
}

int main() {
    // コピーが動いてしまう
    std::vector<int> ret = func();

    // かといって参照もできない
    std::vector<int>& ret = func();    

    // コピーが動かないように、こういうことをしていた
    std::vector<int> ret;
    func2(ret);

    return 0;
}

// 昔のcppでは見なかったものが追加されています。★印部分。
template <typename T>
class stack
{
 public:
    stack(); // デフォルトコンストラクタ
    stack(const stack& rhs); // コピーコンストラクタ
    stack(stack&& rhs); // ★ムーブコンストラクタ 

    stack& operator=(const stack& rhs); // 代入演算子
    stack& operator=(stack&& rhs); // ★ムーブ代入演算子

 private:
    array* p_;
};

// ムーブと聞いてもイマイチピンと来ないので何をやっているか実装例を見せます
template <typename T>
stack<T>::stack(const stack& rhs)  // コピーコンストラクタ
    : p_(new array()) {
    
    for (auto e : rhs.p_) {
        p_->add(e);// コピーしています。コピー元もそのまま使えます
    }
}

template <typename T>
stack<T>::stack(stack&& rhs)  // コピーコンストラクタ
    : p_(nullptr) {
    
    p_ = rhs.p_;// コピーしていません。コピー元もそのまま使えます
    rhs.p_ = nullptr;// モーブ元は使えません
}

auto dst = std::move(src)); // std::moveを使うことでムーブを呼べます
auto dst = src; // 普通にコピーする限りはムーブは絶対に呼べません
auto dst = return_src(); // 戻り値に関しては特例としてmoveが呼ばれます。元のオブジェクトが不要となるため

Obj func_RVO() {
    // return式中で確保されるメモリは呼び出し側になるように最適化される。
    // つまり、ムーブもコピーも動かない
    return Obj{1,2,3};
}

Obj func_NRVO() {    
    // return式中で確保していなくても呼び出し側で確保できれば最適化される
    auto m = Obj{1,2,3};
    return m;
}

int main() {
    
    auto ret = func_RVO();  //func_RVO中でretに直接値が書き込まれる
    auto ret = func_NRVO(); //func_NRVO中でretに直接値が書き込まれる

    return 0;
}

void f1(const string& s);  // OK: pass by reference to const; always cheap

void f2(string s);         // bad: potentially expensive

void f3(int x);            // OK: Unbeatable

void f4(const int& x);     // bad: overhead on access in f4()

void update(Record& r);  // assume that update writes to r

template<class F, class... Args>
inline auto invoke(F f, Args&&... args)
{
    return f(forward<Args>(args)...);
}

template<class F, class... Args>
inline auto invoke(F f, Args&&... args)
{
    return f(std::move(args)...);
}

for(std::vector<Obj>::iterator it = v.begin();it!=v.end();it++) {
    std::cout << it->value << std::endl;
}

for(const auto& item : v) {
    std::cout << item.value << std::endl;
}

using IO = FOO::BAR::HOGE::IO;

if (IO::FILE = type) return 0;
if (IO::SOCKET = type) return 1;
if (IO::STDIN = type) return 2;
if (IO::STDOUT = type) return 3;

class MyBaseClass
{
    public :
    virtual void foo() = 0;
}

class MyClass : public MyBaseClass
{
    void foo() : override;
}

// MyClass::foo() の実装がなければエラー

class MyClass
{
    MyClass(const MyClass&) = delete;
    MyClass(MyClass&&) = delete;
    MyClass& operator=(const MyClass&) = delete;
    MyClass& operator=(MyClass&&) = delete;
}

// 本当はconstなローカル変数にしたいが特定の初期化手順が必要な場合に
// ラムダを使用したカプセル可が期待できます。
const widget x = [&] {
    widget val;  // assume that widget has a default constructor
    for (auto i = 2; i <= N; ++i) {            // this could be some
        val += some_obj.do_something_with(i);  // arbitrarily long code
    }                                          // needed to initialize x
    return val;
}();

int local = 42;
// Want a copy of local.
// Since a copy of local is made, it will
// always be available for the call.
thread_pool.queue_work([=] { process(local); });

std::string s  =  "(this string contains \"double quote\".)";// \が必要になる
std::string s1 = R"(this string contains "double quote".)";
std::u8string s_utf8 = u8R"(this string contains "double quote"(utf-8).)";