Visual Studio 2010 공식 팀 블로그 @vsts2010

template<class InputIterator, class OutputIterator1, class OutputIterator2, class Predicate>

    pair<OutputIterator1, OutputIterator2>

        partition_copy(

            InputIterator _First,

            InputIterator _Last,

            OutputIterator1 _Dest1,

            OutputIterator2 _Dest2,

            Predicate _Pred

        );

template<class InputIterator, class OutputIterator, class BinaryPredicate>
    OutputIterator copy_if(
        InputIterator_First, 
        InputIterator _Last,
        BinaryPredicate _Comp
    );

template<class _InIt,
	class _OutIt,
	class _Pr> inline
	_OutIt copy_if(_InIt _First, _InIt _Last, _OutIt _Dest,
		_Pr _Pred)

template<class InputIterator, class Size, class OutputIterator>
    OutputIterator copy_n(
        InputIterator  _First, 
        Size _Count,
        OutputIterator _Dest
    );

  1 	copy_n(src.begin(), 3, back_inserter(dest));

template<class InputIterator, class Predicate>
    InputIterator find_if_not(
        InputIterator _First, 
        InputIterator _Last,
        BinaryPredicate _Comp
    );

	const int N=12;
	list<int> src;
	list<int> dest;
	// 데이터 초기화
	for(int i=1 ; i<=N ; i++)
		src.push_back(i);
 
	// 약수만을 복사
	copy_if(src.begin(), src.end(), back_inserter(dest), [=](int n){ return N % n == 0; });
	// 3개만 복사
	auto pos = find_if_not(src.cbegin(), src.cend(), [=](int n){ return N % n == 0; });
 
 
	// 결과 출력
	cout<<N<<"의 약수 : ";
	for_each(dest.cbegin(), dest.cend(), [](int n){cout << n << " ";});
	cout<<endl;
	cout<<N<<"의 약수가 아닌 가장 작은 자연수 : "<< *pos <<endl;

#include <vector>

#include <iostream>

#include <time.h>

#include <set>

#include <algorithm>

const unsigned N = 3001;

extern bool some_test;

std::set<int>

get_set(int)

{

    std::set<int> s;

    for (int i = 0; i < N; ++i)

        while (!s.insert(std::rand()).second)

            ;

    if (some_test)

        return s;

    return std::set<int>();

}

std::vector<std::set<int> >

generate()

{

    std::vector<std::set<int> > v;

    for (int i = 0; i < N; ++i)

        v.push_back(get_set(i));

    if (some_test)

        return v;

    return std::vector<std::set<int> >();

}

float time_it()

{

    clock_t t1, t2, t3, t4;

    clock_t t0 = clock();

    {

    std::vector<std::set<int> > v = generate();

    t1 = clock();

    std::cout << "construction took " << (float)((t1 - t0)/(double)CLOCKS_PER_SEC) << std::endl;

    std::sort(v.begin(), v.end());

    t2 = clock();

    std::cout << "sort took " << (float)((t2 - t1)/(double)CLOCKS_PER_SEC) << std::endl;

    std::rotate(v.begin(), v.begin() + v.size()/2, v.end());

    t3 = clock();

    std::cout << "rotate took " << (float)((t3 - t2)/(double)CLOCKS_PER_SEC) << std::endl;

    }

    t4 = clock();

    std::cout << "destruction took " << (float)((t4 - t3)/(double)CLOCKS_PER_SEC) << std::endl;

    std::cout << "done" << std::endl;

    return (float)((t4-t0)/(double)CLOCKS_PER_SEC);

}

int main()

{

    std::cout << "N = " << N << '\n';

    float t = time_it();

    std::cout << "Total time = " << t << '\n';

}

bool some_test = true;

#include "stdafx.h"


template<int> void f(){};

void g()
{
    f<nullptr>();
}

template<template <class> class> class C {};

void test()
{
    auto x = nullptr;
    x++; // should give error
    x += 1; // should give error
}

 int _tmain(int argc, _TCHAR* argv[])
{
    C<nullptr> c;
    test();

    return 0;
}

template <class InputIterator, class Predicate>
  bool none_of(InputIterator first, InputIterator last, Predicate pred);

template <class InputIterator, class Predicate>
  bool any_of(InputIterator first, InputIterator last, Predicate pred);

template <class InputIterator, class Predicate>
  bool all_of(InputIterator first, InputIterator last, Predicate pred);

  1 auto sp = make_shared<int>(1);

  1 shared_ptr<int> sp(new int(1));

void Function_Arg1(int arg1)

{

cout << "Function_Arg1 : " << arg1 << endl;

}

void Function_Arg2(int arg1, const char* arg2)

{

cout << "Function_Arg2 : " << arg1 << "," << arg2 << endl;

}

int arg1 = 1004;

const char* arg2 = "Lambda!";

vector<ITask*> taskList;

// 1. 컨테이너에 담는다.

taskList.push_back( new Task_1<void, int>(&Function_Arg1, arg1) );

taskList.push_back( new Task_2<void, int, const char*>(&Function_Arg2, arg1, arg2) );

…

// 2. 특정 시점에 컨테이너를 순회하며 실행시킨다.

for( auto i = taskList.begin(); i != taskList.end(); ++i )

{

(*i)->Do();

}

template<typename RetType, typename ArgType1>

class Task_1 : public ITask

{

typedef function<RetType(ArgType1)> FunctionType;

public:

Task_1(FunctionType f, ArgType1 a1)

: function_(f), arg1_(a1)

{

}

virtual void Do()

{

cout << "Task_1::Do()" << endl;

function_(arg1_);

}

private:

FunctionType   function_;

ArgType1       arg1_;

};

// 파라미터 2개짜리 함수를 담기 위한 템플릿 클래스

template<typename RetType, typename ArgType1, typename ArgType2>

class Task_2 : public ITask

{

typedef function<RetType(ArgType1,ArgType2)> FunctionType;

public:

Task_2(FunctionType f, ArgType1 a1, ArgType2 a2)

: function_(f), arg1_(a1), arg2_(a2)

{

}

virtual void Do()

{

cout << "Task_2::Do()" << endl;

…

…

int arg1 = 1004;

const char* arg2 = "Lambda!"; 

...
...
typedef function<void(void)> LambdaType;

vector<LambdaType> lambdaList;

lambdaList.push_back( [=](){ Function_Arg1(arg1); } );

lambdaList.push_back( [=](){ Function_Arg2(arg1, arg2); } );

for_each( lambdaList.begin(), lambdaList.end(), [](LambdaType lambda)

{

lambda();

});

TaskManager manager;

…

// TaskManager에 Task로 저장한다.

manager.AddTask( [](){ cout << “task1” << endl;} );

manager.AddTask( [](){ cout << “task2” << endl;} );

…

// 같은 스레드 혹은 다른 스레드에서 실행시킨다.

manager.Run();

class Client

{

public:

// 비동기 요청에 대한 결과를 처리할 람다 함수 타입

typedef function<void(int result)> AsynResultProcessor;

public:

void AsyncRequest(AsynResultEvent resultEvent)

{

resultEvent_ = resultEvent;

}

void Process()

{

Result_ = 1004;

// 미리 저장된 결과 처리 람다 함수를 호출한다.

resultProcessor_(result_);

}

private:

AsynResultProcessor    resultProcessor_;

int                      result_;

};

…

…

Client client;

// 응답을 어떻게 처리할 것인지 요청 시 기술할 수 있다.

client.AsyncRequest( [](int result)

{

// 어떻게 결과를 처리할 것인지 기술

cout << result << endl;

});

…

…

// 특정 시점에 처리한다.

client.Process();

//  for_each()를 위한 함수 객체

//  일회성 호출을 위해 많은 코드가 필요하고 가독성도 떨어진다.

struct LambdaFunctor

{

void operator()(int n) const

{

cout << n << " ";

}

};

int main()

{

vector<int> v;

for (int i = 0; i < 10; ++i)

{

v.push_back(i);

}

// 1. 함수 객체를 이용한 코드

for_each(v.begin(), v.end(), LambdaFunctor());

// 2. 람다 함수를 이용한 코드

for_each(v.begin(), v.end(), [](int n) { cout << n << " "; });

cout << endl;

}

{

string text = "C++0x Lambda!";

// 1. "코드 조각" 변수에 대입하기

function<void()> lambda = [=]()

{                               

cout << text << endl;

};

// 2. "코드 조각"을 자료구조에 저장하기

vector< function<void()> > container;

{               

container.push_back( lambda );

container.push_back( [=](){ cout << text << endl; } );

};

// 3. "코드 조각"을 함수의 입력 파라미터로 사용하기

for_each( container.begin(), container.end(), [](const function<void()>& f){ f(); } );

return 0;

}

int main()

{

// 1. 람다 함수를 반환 값으로 한다.

auto g = [](int x) -> function<int (int)>

{          

return [=](int y) { return x + y; };

};

// 2. 람다 함수를 입력 값으로 받는다.

auto h = [](const function<int (int)>& f, int z)

{

return f(z) + 1;

};

auto a = h( g(7), 8 );

cout << a << endl;

}

…

void capture()

{

int a = 0;

int b = 1;

int c = 2;

// 1. default 값 복사 캡처. 상위 코드 블록의 지역 변수 모두 값 복사 가능

[=](){ cout << a << “ “ << b << endl; }();  // 0 1 출력

// 2. default 값 참조 캡처. 상위 코드 블록의 지역 변수 모두 값 참조 가능

[&](){ cout << a << “ “ << b++ << endl;}(); // 0 1 출력

// 3. default 값 복사 캡처, b와 c 참조 캡처

[=, &b, &c](){ cout << a << “ “ << b << “ ” << c << endl; }();  // 0 2 2 출력

}

…

#include <iostream>

#include <vector>

#include <string>

#include <algorithm>

#include <functional>

using namespace std;

int main()

{

string text = "C++0x Lambda!";

// 1. "코드 조각" 변수에 대입하기

function<void()> lambda = [=]()

{                               

cout << text << endl;

};

// 2. "코드 조각"을 자료구조에 저장하기

vector< function<void()> > container;

{               

container.push_back( lambda );

container.push_back( [=](){ cout << text << endl; } );

};

// 3. "코드 조각"을 함수의 입력 파라미터로 사용하기

for_each( container.begin(), container.end(), [](const function<void()>& f){ f(); } );

return 0;

}

...

void outer_function()

{

void inner_function()

{

}

}

…

void outer_function()

{

// 이름 없는 함수! 람다!

[](){}();

}

…

#include <iostream>

using namespace std;

void func( int a )

{

cout << "func - int " << endl;

}

void func( double *p )

{

cout << "func - double * " << endl;

}

int main()

{

func( static_cast<double*>(0) );

func( 0 );

  func( NULL );

getchar();

return 0;

}

const class {

public:

    template <class T>

    operator T*() const

    {

        return 0;

    }

    template <class C, class T>

    operator T C::*() const

    {

        return 0;

    }

private:

    void operator&() const;

} nullptr = {};

char* ch = nullptr; // ch에 널 포인터 대입.

sizeof( nullptr ); // 사용 할 수 있습니다. 참고로 크기는 4 입니다.

typeid( nullptr ); // 사용할 수 있습니다.

throw nullptr; // 사용할 수 있습니다.

int n = nullptr; // int에는 숫자만 대입가능한데 nullptr은 클래스이므로 안됩니다.

Int n2 = 0

if( n2 == nullptr ); // 에러

if( nullptr ); // 에러

if( nullptr == 0 ); // 에러

nullptr = 0; // 에러

nullptr + 2; // 에러