Category Archives: C++

is_sameで同じ型かどうかを判定する。
declspecで式から型を得る。
invoke_resultで関数の戻り値の型を得る。

#include <type_traits>
#include <cstdint>

static constexpr int64_t g = 1234;

double ddd()
{
    return 1.234;
}

int ccc(char c)
{
    return c + 3;
}
int main()
{
    auto val = false;
    
    // check val is bool
    static_assert(std::is_same<decltype(val), bool>::value, "retval must be bool");

    int i = 100;
    static_assert(std::is_same<decltype(i * g), int64_t>::value, "i * g must be int64_t");

    // invoke_result needs C++ 17
    static_assert(std::is_same<std::invoke_result<decltype(ddd)>::type, double>::value, "ddd must return double");

    // invoke_result needs C++ 17
    static_assert(std::is_same<std::invoke_result<decltype(ccc), char>::type, int>::value, "ccc must return int");
}

#include <type_traits>

#include <cstdint>

static constexpr int64_t g = 1234;

double ddd()

{

return 1.234;

}

int ccc(char c)

{

return c + 3;

}

int main()

{

auto val = false;

// check val is bool

static_assert(std::is_same<decltype(val), bool>::value, "retval must be bool");

int i = 100;

static_assert(std::is_same<decltype(i * g), int64_t>::value, "i * g must be int64_t");

// invoke_result needs C++ 17

static_assert(std::is_same<std::invoke_result<decltype(ddd)>::type, double>::value, "ddd must return double");

// invoke_result needs C++ 17

static_assert(std::is_same<std::invoke_result<decltype(ccc), char>::type, int>::value, "ccc must return int");

}

ソース：https://github.com/ambiesoft/blogprogs/tree/master/5775/static_assert_type_check

emplace_backでムーブコンストラクタがあるのにコピーコンストラクタが呼ばれる

2021年5月9日

admin

C++ No Comments

puch_backよりもemplace_backがいいと言われていて実験したら、push_backだとコピーコンストラクタが呼ばれないのに、emplace_backだと呼ばれる現象が発生。

結論

ムーブコンストラクタにnoexceptをつければコピーコンストラクタの代わりにムーブコンストラクタが呼ばれる。

#include <iostream>
#include <vector>
#include <string>
#include <cassert>
#include <iostream>

class MyKlass {
	int ii_;
	float ff_;
	std::string ss_;
public:
	MyKlass(int ii, float ff, const std::string& ss) :
		ii_(ii), ff_(ff), ss_(ss) {
		std::cout << "ctor" << std::endl;
	}
	MyKlass(const MyKlass& that) :
		ii_(that.ii_), ff_(that.ff_), ss_(that.ss_) {
		std::cout << "copy" << std::endl;
	}
	MyKlass(MyKlass&& that) :
		ii_(that.ii_), ff_(that.ff_), ss_(std::move(that.ss_)) {
		std::cout << "move" << std::endl;
	}

	~MyKlass() {
		std::cout << "dtor" << std::endl;
	}
};

// just add 'noexcept' to move ctor
class MyKlassWithNoExcept {
	int ii_;
	float ff_;
	std::string ss_;
public:
	MyKlassWithNoExcept(int ii, float ff, const std::string& ss) :
		ii_(ii), ff_(ff), ss_(ss) {
		std::cout << "ctor" << std::endl;
	}
	MyKlassWithNoExcept(const MyKlassWithNoExcept& that) :
		ii_(that.ii_), ff_(that.ff_), ss_(that.ss_) {
		std::cout << "copy" << std::endl;
	}
	MyKlassWithNoExcept(MyKlassWithNoExcept&& that) noexcept :
		ii_(that.ii_), ff_(that.ff_), ss_(std::move(that.ss_)) {
		std::cout << "move" << std::endl;
	}

	~MyKlassWithNoExcept() {
		std::cout << "dtor" << std::endl;
	}
};

int main()
{
	// without noexcept
	{
		{
			std::vector<MyKlass> v;
			v.emplace_back(2, 3.14f, "jio");  // ctor
			std::cout << "---" << std::endl;
			
			v.emplace_back(2, 3.14f, "jio");  // ctor, copy, dtor
			std::cout << "---" << std::endl;
			
			v.emplace_back(2, 3.14f, "jio");  // ctor, copy, copy, dtor, dtor
			std::cout << "---" << std::endl;
		}

		std::cout << "------------------" << std::endl;

		{
			std::vector<MyKlass> v;
			v.push_back(MyKlass(2, 3.14f, "jij"));  // ctor, move, dtor
			std::cout << "---" << std::endl;

			v.push_back(MyKlass(2, 3.14f, "jij"));  // ctor, move, copy, dtor, dtor
			std::cout << "---" << std::endl;
			
			v.push_back(MyKlass(2, 3.14f, "jij"));  // ctor, move, copy, copy, dtor, dtor, dtor
			std::cout << "---" << std::endl;
		}

		std::cout << "------------------" << std::endl;
	}

	// with noexcept
	{
		{
			std::vector<MyKlassWithNoExcept> v;
			v.emplace_back(2, 3.14f, "jio");  // ctor
			std::cout << "---" << std::endl;

			v.emplace_back(2, 3.14f, "jio");  // ctor, move, dtor
			std::cout << "---" << std::endl;

			v.emplace_back(2, 3.14f, "jio");  // ctor, move, move, dtor, dtor
			std::cout << "---" << std::endl;
		}

		std::cout << "------------------" << std::endl;

		{
			std::vector<MyKlassWithNoExcept> v;
			v.push_back(MyKlassWithNoExcept(2, 3.14f, "jij"));  // ctor, move, dtor
			std::cout << "---" << std::endl;

			v.push_back(MyKlassWithNoExcept(2, 3.14f, "jij"));  // ctor, move, move, dtor, dtor
			std::cout << "---" << std::endl;

			v.push_back(MyKlassWithNoExcept(2, 3.14f, "jij"));  // ctor, move, move, move, dtor, dtor, dtor
			std::cout << "---" << std::endl;
		}

		std::cout << "------------------" << std::endl;
	}

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

#include <iostream>

#include <vector>

#include <string>

#include <cassert>

#include <iostream>

class MyKlass {

int ii_;

float ff_;

std::string ss_;

public:

MyKlass(int ii, float ff, const std::string& ss) :

ii_(ii), ff_(ff), ss_(ss) {

std::cout << "ctor" << std::endl;

}

MyKlass(const MyKlass& that) :

ii_(that.ii_), ff_(that.ff_), ss_(that.ss_) {

std::cout << "copy" << std::endl;

}

MyKlass(MyKlass&& that) :

ii_(that.ii_), ff_(that.ff_), ss_(std::move(that.ss_)) {

std::cout << "move" << std::endl;

}

~MyKlass() {

std::cout << "dtor" << std::endl;

}

};

// just add 'noexcept' to move ctor

class MyKlassWithNoExcept {

int ii_;

float ff_;

std::string ss_;

public:

MyKlassWithNoExcept(int ii, float ff, const std::string& ss) :

ii_(ii), ff_(ff), ss_(ss) {

std::cout << "ctor" << std::endl;

}

MyKlassWithNoExcept(const MyKlassWithNoExcept& that) :

ii_(that.ii_), ff_(that.ff_), ss_(that.ss_) {

std::cout << "copy" << std::endl;

}

MyKlassWithNoExcept(MyKlassWithNoExcept&& that) noexcept :

ii_(that.ii_), ff_(that.ff_), ss_(std::move(that.ss_)) {

std::cout << "move" << std::endl;

}

~MyKlassWithNoExcept() {

std::cout << "dtor" << std::endl;

}

};

int main()

{

// without noexcept

{

std::vector<MyKlass> v;

v.emplace_back(2, 3.14f, "jio"); // ctor

std::cout << "---" << std::endl;

v.emplace_back(2, 3.14f, "jio"); // ctor, copy, dtor

std::cout << "---" << std::endl;

v.emplace_back(2, 3.14f, "jio"); // ctor, copy, copy, dtor, dtor

std::cout << "---" << std::endl;

}

std::cout << "------------------" << std::endl;

{

std::vector<MyKlass> v;

v.push_back(MyKlass(2, 3.14f, "jij")); // ctor, move, dtor

std::cout << "---" << std::endl;

v.push_back(MyKlass(2, 3.14f, "jij")); // ctor, move, copy, dtor, dtor

std::cout << "---" << std::endl;

v.push_back(MyKlass(2, 3.14f, "jij")); // ctor, move, copy, copy, dtor, dtor, dtor

std::cout << "---" << std::endl;

}

std::cout << "------------------" << std::endl;

}

// with noexcept

{

std::vector<MyKlassWithNoExcept> v;

v.emplace_back(2, 3.14f, "jio"); // ctor

std::cout << "---" << std::endl;

v.emplace_back(2, 3.14f, "jio"); // ctor, move, dtor

std::cout << "---" << std::endl;

v.emplace_back(2, 3.14f, "jio"); // ctor, move, move, dtor, dtor

std::cout << "---" << std::endl;

}

std::cout << "------------------" << std::endl;

{

std::vector<MyKlassWithNoExcept> v;

v.push_back(MyKlassWithNoExcept(2, 3.14f, "jij")); // ctor, move, dtor

std::cout << "---" << std::endl;

v.push_back(MyKlassWithNoExcept(2, 3.14f, "jij")); // ctor, move, move, dtor, dtor

std::cout << "---" << std::endl;

v.push_back(MyKlassWithNoExcept(2, 3.14f, "jij")); // ctor, move, move, move, dtor, dtor, dtor

std::cout << "---" << std::endl;

}

std::cout << "------------------" << std::endl;

}

ソース：https://github.com/ambiesoft/blogprogs/tree/master/5767

C++/CLIのBeginInvoke

2021年1月6日

admin

C++ No Comments

BeginInvokeはInvokeと違って、非同期でデリゲートを呼び出します。別スレッドで実行されるので注意が必要です。待ったりするときはIAsyncResultを使います。

なおここで紹介しているBeginInvokeはControl::BeginInvokeとは違うものなので注意が必要です。

最もシンプル

#include "stdafx.h"

using namespace System;

delegate void VVDelegate(void);

void myfunc(void)
{
	System::Threading::Thread::Sleep(3000);
}

int main()
{
	VVDelegate^ dele = gcnew VVDelegate(&myfunc);
	IAsyncResult^ result = dele->BeginInvoke(nullptr, nullptr);
	dele->EndInvoke(result);
	return 0;
}

#include "stdafx.h"

using namespace System;

delegate void VVDelegate(void);

void myfunc(void)

{

System::Threading::Thread::Sleep(3000);

}

int main()

{

VVDelegate^ dele = gcnew VVDelegate(&myfunc);

IAsyncResult^ result = dele->BeginInvoke(nullptr, nullptr);

dele->EndInvoke(result);

return 0;

}

引数を渡す

#include "stdafx.h"

using namespace System;

delegate void VIDelegate(int);

void myfunc(int i)
{
	System::Threading::Thread::Sleep(i);
}

int main()
{
	VIDelegate^ dele = gcnew VIDelegate(&myfunc);
	IAsyncResult^ result = dele->BeginInvoke(1000,nullptr,nullptr);
	dele->EndInvoke(result);
	return 0;
}

#include "stdafx.h"

using namespace System;

delegate void VIDelegate(int);

void myfunc(int i)

{

System::Threading::Thread::Sleep(i);

}

int main()

{

VIDelegate^ dele = gcnew VIDelegate(&myfunc);

IAsyncResult^ result = dele->BeginInvoke(1000,nullptr,nullptr);

dele->EndInvoke(result);

return 0;

}

２つの引数を渡す

#include "stdafx.h"

using namespace System;

delegate void VISDelegate(int, String^ s);

void myfunc(int i, String^ s)
{
	Console::WriteLine(s);
	System::Threading::Thread::Sleep(i);
}

int main()
{
	VISDelegate^ dele = gcnew VISDelegate(&myfunc);
	IAsyncResult^ result = dele->BeginInvoke(1000, "Hello World!", nullptr, nullptr);
	dele->EndInvoke(result);
	return 0;
}

#include "stdafx.h"

using namespace System;

delegate void VISDelegate(int, String^ s);

void myfunc(int i, String^ s)

{

Console::WriteLine(s);

System::Threading::Thread::Sleep(i);

}

int main()

{

VISDelegate^ dele = gcnew VISDelegate(&myfunc);

IAsyncResult^ result = dele->BeginInvoke(1000, "Hello World!", nullptr, nullptr);

dele->EndInvoke(result);

return 0;

}

コールバックを設定してコールしてもらう

#include "stdafx.h"

using namespace System;

delegate void VISDelegate(int, String^ s);

void myfunc(int i, String^ s)
{
	Console::WriteLine(s);
	System::Threading::Thread::Sleep(i);
}
void MyAsyncCallback(IAsyncResult^ ar)
{
	Console::WriteLine("CallBack called");
}
int main()
{
	VISDelegate^ dele = gcnew VISDelegate(&myfunc);
	AsyncCallback^ callback = gcnew AsyncCallback(&MyAsyncCallback);
	Console::WriteLine("Before BeginInvoke");
	IAsyncResult^ result = dele->BeginInvoke(1000, "Hello World!", callback, nullptr);
	Console::WriteLine("After BeginInvoke");
	dele->EndInvoke(result);
	Console::WriteLine("After EndInvoke");
	
	return 0;
}

#include "stdafx.h"

using namespace System;

delegate void VISDelegate(int, String^ s);

void myfunc(int i, String^ s)

{

Console::WriteLine(s);

System::Threading::Thread::Sleep(i);

}

void MyAsyncCallback(IAsyncResult^ ar)

{

Console::WriteLine("CallBack called");

}

int main()

{

VISDelegate^ dele = gcnew VISDelegate(&myfunc);

AsyncCallback^ callback = gcnew AsyncCallback(&MyAsyncCallback);

Console::WriteLine("Before BeginInvoke");

IAsyncResult^ result = dele->BeginInvoke(1000, "Hello World!", callback, nullptr);

Console::WriteLine("After BeginInvoke");

dele->EndInvoke(result);

Console::WriteLine("After EndInvoke");

return 0;

}

コールバック関数に値を渡す

#include "stdafx.h"

using namespace System;

delegate void VISDelegate(int, String^ s);

void myfunc(int i, String^ s)
{
	Console::WriteLine(s);
	System::Threading::Thread::Sleep(i);
}
void MyAsyncCallback(IAsyncResult^ ar)
{
	Console::WriteLine("CallBack called");
	Console::WriteLine(ar->AsyncState);
}
int main()
{
	VISDelegate^ dele = gcnew VISDelegate(&myfunc);
	AsyncCallback^ callback = gcnew AsyncCallback(&MyAsyncCallback);
	Console::WriteLine("Before BeginInvoke");
	IAsyncResult^ result = dele->BeginInvoke(1000, "Hello World!", callback, 12345);
	Console::WriteLine("After BeginInvoke");
	dele->EndInvoke(result);
	Console::WriteLine("After EndInvoke");

	return 0;
}

#include "stdafx.h"

using namespace System;

delegate void VISDelegate(int, String^ s);

void myfunc(int i, String^ s)

{

Console::WriteLine(s);

System::Threading::Thread::Sleep(i);

}

void MyAsyncCallback(IAsyncResult^ ar)

{

Console::WriteLine("CallBack called");

Console::WriteLine(ar->AsyncState);

}

int main()

{

VISDelegate^ dele = gcnew VISDelegate(&myfunc);

AsyncCallback^ callback = gcnew AsyncCallback(&MyAsyncCallback);

Console::WriteLine("Before BeginInvoke");

IAsyncResult^ result = dele->BeginInvoke(1000, "Hello World!", callback, 12345);

Console::WriteLine("After BeginInvoke");

dele->EndInvoke(result);

Console::WriteLine("After EndInvoke");

return 0;

}

クラスの関数で

#include "stdafx.h"

using namespace System;

delegate void VVDelegate(void);

ref class MyClass
{
public:
	static void mystaticfunc(void)
	{
		System::Threading::Thread::Sleep(3000);
	}
	void myinstfunc(void)
	{
		System::Threading::Thread::Sleep(3000);
	}
};

int main()
{
	{
		VVDelegate^ dele = gcnew VVDelegate(&MyClass::mystaticfunc);
		IAsyncResult^ result = dele->BeginInvoke(nullptr, nullptr);
		dele->EndInvoke(result);
	}
	{
		MyClass^ myClass = gcnew MyClass();
		VVDelegate^ dele = gcnew VVDelegate(myClass, &MyClass::myinstfunc);
		IAsyncResult^ result = dele->BeginInvoke(nullptr, nullptr);
		dele->EndInvoke(result);
	}
	return 0;
}

#include "stdafx.h"

using namespace System;

delegate void VVDelegate(void);

ref class MyClass

{

public:

static void mystaticfunc(void)

{

System::Threading::Thread::Sleep(3000);

}

void myinstfunc(void)

{

System::Threading::Thread::Sleep(3000);

}

};

int main()

{

VVDelegate^ dele = gcnew VVDelegate(&MyClass::mystaticfunc);

IAsyncResult^ result = dele->BeginInvoke(nullptr, nullptr);

dele->EndInvoke(result);

}

{

MyClass^ myClass = gcnew MyClass();

VVDelegate^ dele = gcnew VVDelegate(myClass, &MyClass::myinstfunc);

IAsyncResult^ result = dele->BeginInvoke(nullptr, nullptr);

dele->EndInvoke(result);

}

return 0;

}

２つのBeginInvokeを同時に待つ

#include "stdafx.h"

using namespace System;

delegate void VVDelegate(void);

ref class MyClass
{
public:
	static void mystaticfunc(void)
	{
		System::Threading::Thread::Sleep(3000);
	}
	void myinstfunc(void)
	{
		System::Threading::Thread::Sleep(3000);
	}
};

int main()
{
	IAsyncResult^ result1;
	IAsyncResult^ result2;

	{
		VVDelegate^ dele = gcnew VVDelegate(&MyClass::mystaticfunc);
		result1 = dele->BeginInvoke(nullptr, nullptr);
	}
	{
		MyClass^ myClass = gcnew MyClass();
		VVDelegate^ dele = gcnew VVDelegate(myClass, &MyClass::myinstfunc);
		result2 = dele->BeginInvoke(nullptr, nullptr);
	}

	array<System::Threading::WaitHandle^>^ waitHandles = gcnew array<System::Threading::WaitHandle^>(2);
	waitHandles[0] = result1->AsyncWaitHandle;
	waitHandles[1] = result2->AsyncWaitHandle;
	System::Threading::WaitHandle::WaitAll(waitHandles);
	return 0;
}

#include "stdafx.h"

using namespace System;

delegate void VVDelegate(void);

ref class MyClass

{

public:

static void mystaticfunc(void)

{

System::Threading::Thread::Sleep(3000);

}

void myinstfunc(void)

{

System::Threading::Thread::Sleep(3000);

}

};

int main()

{

IAsyncResult^ result1;

IAsyncResult^ result2;

{

VVDelegate^ dele = gcnew VVDelegate(&MyClass::mystaticfunc);

result1 = dele->BeginInvoke(nullptr, nullptr);

}

{

MyClass^ myClass = gcnew MyClass();

VVDelegate^ dele = gcnew VVDelegate(myClass, &MyClass::myinstfunc);

result2 = dele->BeginInvoke(nullptr, nullptr);

}

array<System::Threading::WaitHandle^>^ waitHandles = gcnew array<System::Threading::WaitHandle^>(2);

waitHandles[0] = result1->AsyncWaitHandle;

waitHandles[1] = result2->AsyncWaitHandle;

System::Threading::WaitHandle::WaitAll(waitHandles);

return 0;

}

ソースコード

https://github.com/ambiesoft/blogprogs/tree/master/5753

std::vectorのソート

2020年8月3日

admin

C++ No Comments

std::sort(
  examples.begin(),
  examples.end(),
  [](const auto& a, const auto& b) {
    return a->example_title() < b->example_title();
  });

std::sort(

examples.begin(),

examples.end(),

[](const auto& a, const auto& b) {

return a->example_title() < b->example_title();

});

enable_if

2020年5月28日

admin

C++ 未分類 No Comments

enable_ifによりある条件のときだけtemplateを有効にすることができる。逆に言うとtemplateにしたくない条件を無効化することができる。

// 5-example.cpp : This file contains the 'main' function. Program execution begins and ends there.
//

#include <iostream>

template<typename T>
void myfunc(T t)
{
    std::cout << t << "\n";
}

template<typename T,
    typename = std::enable_if_t<std::is_convertible_v<T, int>>>
    void myintfunc(T t)
{

}
template<typename T,
    typename = std::enable_if<std::is_convertible<T, int>::value>::type>
    void myintfunc_old(T t)
{

}
int main()
{
    myfunc('a');
    myfunc(10);
    myfunc("hello");
    myfunc(std::string("hello2"));

    myintfunc('a');
    myintfunc(10);


    /*
        error C2672: 'myintfunc': no matching overloaded function found
        error C2783: 'void myintfunc(T)': could not deduce template argument for '<unnamed-symbol>'
        message : see declaration of 'myintfunc'
    */
    // myintfunc("hello");

    myintfunc_old('a');
    myintfunc_old(10);
    // myintfunc_old("hello");
}

// 5-example.cpp : This file contains the 'main' function. Program execution begins and ends there.

#include <iostream>

template<typename T>

void myfunc(T t)

{

std::cout << t << "\n";

}

template<typename T,

typename = std::enable_if_t<std::is_convertible_v<T, int>>>

void myintfunc(T t)

{

}

template<typename T,

typename = std::enable_if<std::is_convertible<T, int>::value>::type>

void myintfunc_old(T t)

{

}

int main()

{

myfunc('a');

myfunc(10);

myfunc("hello");

myfunc(std::string("hello2"));

myintfunc('a');

myintfunc(10);

error C2672: 'myintfunc': no matching overloaded function found

error C2783: 'void myintfunc(T)': could not deduce template argument for '<unnamed-symbol>'

message : see declaration of 'myintfunc'

// myintfunc("hello");

myintfunc_old('a');

myintfunc_old(10);

// myintfunc_old("hello");

}

std::enable_if_t<std::is_convertible_v<T, int>>はstd::enable_if<std::is_convertible<T, int>::value>::type>と同じことなのでこれについて考える。

全体としての意味はTがintに変換できるときだけテンプレートを有効にするということ。

is_convertible<T, int>はTがintに変換できるかを判定し、その結果はvalueに格納される。

enable_if<A>はAがtrueかどうかを判定し、trueならばtypeに型voidを格納する。falseならエラーになる。

よって全体としてTがintに変換できない場合はエラーになり、templateのインスタンス化は行われない（コンパイルエラーにはならない（SFINAE））。

この例ではどういうときにこれを使うのかの応用例は示せていないが、特定の型のときだけテンプレートを有効にしたい場合に使う。

typename = としているのはtypename A = などと同じでデフォルトのテンプレート引数の指定、これはテンプレートのインスタンス化をするかどうかだけのために使われるので、コード中では使われないのでこういう記述になっている。

Windowsでプロセスで共有する変数を定義する

2020年1月28日

admin

C++ No Comments

sharedセクションをつかう

以下のコードで変数iをプロセスで共有できる。すべてのプロセスがなくなると消える。

#include <iostream>

#if defined(__GNUC__)
    #define shareattr __attribute__((section ("shared"), shared))
#else
    #pragma section("shared",shared)
    #define shareattr __declspec(allocate("shared"))
#endif

shareattr int i=0 ;
using namespace std;

int main()
{
    i++;
    cout << "i=" << i << endl;
    getchar();
    return 0;
}

#include <iostream>

#if defined(__GNUC__)

#define shareattr __attribute__((section ("shared"), shared))

#else

#pragma section("shared",shared)

#define shareattr __declspec(allocate("shared"))

#endif

shareattr int i=0 ;

using namespace std;

int main()

{

i++;

cout << "i=" << i << endl;

getchar();

return 0;

}

プロジェクトは以下を参照
https://github.com/ambiesoft/blogprogs/tree/master/5637

stringのvectorをスペースで区切って１つのstringにする

2019年12月22日

admin

C++ No Comments

TLTR

	vector<string> vs = { "aaa", "bbb", "ccc" };

	ostringstream oss;
	std::copy(vs.begin(), vs.end(),
		ostream_iterator<string>(oss, " "));

vector<string> vs = { "aaa", "bbb", "ccc" };

ostringstream oss;

std::copy(vs.begin(), vs.end(),

ostream_iterator<string>(oss, " "));

ostringstreamとは

<<で渡された値を内部に持っているstringに追加していく。

	ostringstream oss;
	oss << 1 ;
	oss << 10 << "\n";
	oss << 100 << "\n";

	oss << "xxx" << "\n";
	oss << "yyy" << "\n";
	oss << "zzz" << "\n";

	cout << oss.str() << endl;

ostringstream oss;

oss << 1 ;

oss << 10 << "\n";

oss << 100 << "\n";

oss << "xxx" << "\n";

oss << "yyy" << "\n";

oss << "zzz" << "\n";

cout << oss.str() << endl;

ostream_iteratorとは

=で渡された値をコンストラクタで渡された出力ストリームに追加していく。
コンストラクタの２番めの引数はデリミタを指定する。=でストリームに追加したあとにこの値も追加する。デフォルトでは何も追加しない。
++演算では何もしない。これにより下記のcopyで役に立つ。

	{
		ostream_iterator<int> osi(cout, "\n");
		osi = 1;
		osi = 2;
		osi = 3;
	}
	{
		ostream_iterator<string> osi(cout, "\n");
		osi = "osstest1";
		osi = "osstest2";
		osi = "osstest3";
	}

{

ostream_iterator<int> osi(cout, "\n");

osi = 1;

osi = 2;

osi = 3;

}

{

ostream_iterator<string> osi(cout, "\n");

osi = "osstest1";

osi = "osstest2";

osi = "osstest3";

}

上のコードは以下のようにコンソールに出力される。

1
2
3
osstest1
osstest2
osstest3

osstest1

osstest2

osstest3

copyとは

第一引数と第二引数のイテレータで入力範囲を指定する。
第三引数で出力イテレータを指定する。

入力出力とも++で一個ずつずらしていって=でコピーする。

	{
		vector<int> vi = { 1, 2, 3 };
		vector<int> vi2(3);

		copy(vi.begin(), vi.end(),
			vi2.begin());
	}
	{
		vector<string> vs = { "a", "b", "c" };
		vector<string> vs2(3);

		copy(vs.begin(), vs.end(),
			vs2.begin());
	}

{

vector<int> vi = { 1, 2, 3 };

vector<int> vi2(3);

copy(vi.begin(), vi.end(),

vi2.begin());

}

{

vector<string> vs = { "a", "b", "c" };

vector<string> vs2(3);

copy(vs.begin(), vs.end(),

vs2.begin());

}

ostream_iteratorの++は何もしないで=で値をストリームに追加する。（最初のコード参照）