Visual Studio 2010 공식 팀 블로그 @vsts2010

boost::chrono::nanoseconds  // 나노 세컨드. 10억분의 1초

boost::chrono::microseconds // 마이크로 세컨드. 100만분의 1초

boost::chrono::milliseconds  // 밀리 세컨드. 1000분의 1초

boost::chrono::seconds      // 초

boost::chrono::minutes      // 분

boost::chrono::hours        // 시

boost::chrono::hours H1(1); // 1시간

boost::chrono::hours H2(2); // 2시간

boost::chrono::hours H25(25); // ?

 

boost::chrono::seconds S1(10);

boost::chrono::seconds S2(120);

 

boost::chrono::milliseconds MILS1(100);

boost::chrono::hours H1(1);

boost::chrono::hours H2(2);

boost::chrono::hours H3 = H1 + H2;

boost::chrono::seconds S1(10);

boost::chrono::milliseconds MILS1(100);

boost::chrono::milliseconds MILS2 = S1 + MILS1;

boost::chrono::milliseconds MILS2 = S1 + MILS1;

boost::chrono:: seconds S2 = S1 + MILS1;

boost::chrono::seconds S2 = boost::chrono::duration_cast< boost::chrono::seconds >(S1 + MILS1);

#include <boost/chrono.hpp>

int main()
{
    {
        boost::chrono::hours H1(1); // 1시간
        boost::chrono::hours H2(2); // 2시간
        boost::chrono::hours H3(25); // ?

        std::cout << "H1(1) - 문자열 : " << H1 << std::endl;
        std::cout << "H1(1) - 숫자로 : " << H1.count() << std::endl;
        std::cout << "H3(25) - 문자열 : " << H3 << std::endl;
        std::cout << "H3(25) - 숫자로 : " << H3.count() << std::endl;


        boost::chrono::seconds S1(10);
        boost::chrono::seconds S2(120);

        std::cout << "S1(10) - 문자열 : " << S1 << std::endl;
        std::cout << "S1(10) - 숫자로 : " << S1.count() << std::endl;

        std::cout << "S2(120) - 문자열 : " << S2 << std::endl;
        std::cout << "S2(120) - 숫자로 : " << S2.count() << std::endl;
    }

    {
        boost::chrono::hours H1(1);
        boost::chrono::hours H2(2);
        boost::chrono::hours H3 = H1 + H2;

        std::cout << "H1 + H2 = : " << H3 << std::endl;


        boost::chrono::seconds S1(10);
        boost::chrono::milliseconds MILS1(100);
        boost::chrono::milliseconds MILS2 = S1 + MILS1;

        std::cout << "S1 + MILS1 = : " << MILS2 << std::endl;


        boost::chrono::seconds S2 = boost::chrono::duration_cast< boost::chrono::seconds >(S1 + MILS1);

        std::cout << "S1 + MILS1 = : " << S2 << std::endl;
    }



    return 0;
}

boost::chrono::duration<double> sec = boost::chrono::system_clock::now() - start;

nanoseconds - 10억분의 1초

microseconds - 100만분의 1초

milliseconds - 1000분의 1초

seconds – 초

minutes - 분

hours – 시간

#include <boost/chrono.hpp>

#include <cmath>

 

void Test()

{

           for ( long i = 0; i < 10000000; ++i )

           {

                     std::sqrt( 123.456L );

           }

}

 

int main()

{

    boost::chrono::system_clock::time_point StartTime = boost::chrono::system_clock::now();

                    

    Test();

    boost::chrono::system_clock::time_point EndTime = boost::chrono::system_clock::now();

 

    boost::chrono::duration<double> DefaultSec = EndTime - StartTime;

    boost::chrono::nanoseconds nano = EndTime - StartTime;

    boost::chrono::microseconds micro = boost::chrono::duration_cast<boost::chrono::microseconds>(EndTime - StartTime);

    boost::chrono::milliseconds mill = boost::chrono::duration_cast<boost::chrono::milliseconds>(EndTime - StartTime);

    boost::chrono::seconds sec = boost::chrono::duration_cast<boost::chrono::seconds>(EndTime - StartTime);

    boost::chrono::minutes min = boost::chrono::duration_cast<boost::chrono::minutes>(EndTime - StartTime);

    boost::chrono::hours hour = boost::chrono::duration_cast<boost::chrono::hours>(EndTime - StartTime);

 

    std::cout << "Test() 함수를 수행하는 걸린 시간 : " << DefaultSec.count() << " default" << std::endl;

    std::cout << "Test() 함수를 수행하는 걸린 시간 : " << nano.count() << " nanoseconds" << std::endl;

    std::cout << "Test() 함수를 수행하는 걸린 시간 : " << micro.count() << " microseconds" << std::endl;

    std::cout << "Test() 함수를 수행하는 걸린 시간 : " << mill.count() << " milliseconds" << std::endl;

    std::cout << "Test() 함수를 수행하는 걸린 시간 : " << sec.count() << " seconds" << std::endl;

    std::cout << "Test() 함수를 수행하는 걸린 시간 : " << min.count() << " minutes" << std::endl;

    std::cout << "Test() 함수를 수행하는 걸린 시간 : " << hour.count() << " hour" << std::endl;

                    

    return 0;

}

#include <boost/chrono.hpp>

#include <boost/chrono.hpp>

#include <cmath>

 

void Test()

{

           for ( long i = 0; i < 10000000; ++i )

           {

                     std::sqrt( 123.456L );

           }

}

 

int main()

{

    boost::chrono::system_clock::time_point start = boost::chrono::system_clock::now();

                

    Test();

          

    boost::chrono::duration<double> sec = boost::chrono::system_clock::now() - start;

    std::cout << "Test() 함수를 수행하는 걸린 시간(초) : " << sec.count() << " seconds" << std::endl;

 

    return 0;

}

boost::chrono::system_clock::time_point start = boost::chrono::system_clock::now();

boost::chrono::duration<double> sec = boost::chrono::system_clock::now() - start;

class Integer

{

private :

    int value ;

 

public :

    constexpr Integer() : value() { }

    constexpr Integer( int value ) : value(value) { }

 

    constexpr operator int() { return value ; }

} ;

 

int main()

{

    constexpr Integer size = 5 ; // 컴파일 타임에 정수로

 

    int x[size] ; // Integer::operator int()가 호출된다

 

    Integer object ; // 일반적인 클래스 인스턴스 화. 실행 시에 처리

    int y[object] ; // 당근 에러

}

#include <iostream>

 

struct pi {

    static constexpr double value = 3.14;

};

 

template <const double& r>

struct circle_area {

    static constexpr double value = r * r * pi::value;

};

 

struct radius {

    static constexpr double value = 2.5;

};

 

int main()

{

    constexpr double result = circle_area<radius::value>::value;

 

    static_assert(result == 19.625, "not equal");

    std::cout << result << std::endl;

}

constexpr int aa = 11;

const int aa = 11

int input_num = 0;

constexpr int aa = input_num;  // 에러

int GetNum() { retun 5; }

int Numbers[ GetNum() ];

constexpr int GetNum() { retun 5; }

int Numbers[ GetNum() ];

constexpr double power( double x, unsigned int y )

{

    return y == 1 ? x : x * power( x, y - 1 ) ;

}

 

int main()

{

    // 정수 식

    constexpr double a = power( 2, 32 ) ;

 

    // 정수 식이 아니다

    double x = 2 ; unsigned int y = 32 ;

    double b = power( x, y ) ;

}

const int base_HP = 200;

…

int NPC_Lv1_HP = base_HP + 0;

int NPC_Lv2_HP = base_HP + 200;

constexpr int AssignHP( int nPlusHP )

{

 return base_HP + nPlusHP;

}

 

int NPC_Lv1_HP = AssignHP( 0 );

int NPC_Lv2_HP = AssignHP( 200 );

struct Base

{

  virtual void foo( int i );

};

 

struct Derived : Base

{

  virtual void foo( int i );

}

struct Derived : Base

{

  virtual void foo( float i );

}

struct Derived : Base

{

  virtual void foo( float i ) override;

}

struct Base

{

  virtual void foo( int i ) final;

};

 

struct Derived : Base

{

  virtual void foo( int i );

}

#pragma unmanaged

extern "C" void printf(const char*, ...);

class A {

public:

   static void func(char* s) {

      printf(s);

   }

};

 

#pragma managed

public delegate void func(char*);

 

ref class B {

   A* ap;

 

public:

   B(A* ap):ap(ap) {}

   void func(char* s) {

      ap->func(s);

   }

};

 

int main() {

   A* a = new A;

   B^ b = gcnew B(a);

   func^ f = gcnew func(b, &B::func);

   f("hello");

   delete a;

}

using namespace System;

 

class CNative

{

public:

           CNative()

           {

                     Console::WriteLine(__FUNCTION__);

           }

           ~CNative()

           {

                     Console::WriteLine(__FUNCTION__);

           }

};

 

int main(array<System::String ^> ^args)

{

           array<CNative>^ arr = gcnew array<CNative>(2);

           return 0;

}

#include "stdafx.h"

#include <iostream>

using namespace System;

 

class CNative

{

public:

           CNative()

           {

                     Console::WriteLine(__FUNCTION__);

           }

           ~CNative()

           {

                     Console::WriteLine(__FUNCTION__);

           }

};

 

int main(array<System::String ^> ^args)

{

           array<CNative*>^ arr = gcnew array<CNative*>(2);

           for(int i=0; i<arr->Length; i++)

           {

                     arr[i] = new CNative();

           }

 

           getchar();

           return 0;

}

#include "stdafx.h"

#include <iostream>

using namespace System;

 

class CNative

{

public:

           CNative()

           {

                     Console::WriteLine(__FUNCTION__);

           }

           ~CNative()

           {

                     Console::WriteLine(__FUNCTION__);

           }

};

 

int main(array<System::String ^> ^args)

{

           array<CNative*>^ arr = gcnew array<CNative*>(2);

           for(int i=0; i<arr->Length; i++)

           {

                     arr[i] = new CNative();

           }

 

           for(int i=0; i<arr->Length; i++)

           {

                     delete arr[i];

           }

          

           getchar();

           return 0;

}

함수

프로퍼티

이벤트

interface class IA {

public:

    void funcIA();

};

interface class IB {

public:

    void funcIB();

};

interface class IC {

public:

    void funcIC();

};

ref class A {

    int i;

};

ref class B : A, IA, IB, IC {

public:

    virtual void funcIA() {   }

    virtual void funcIB() {   }

    virtual void funcIC() {   }

};

int main() {

    B^ b = gcnew B;

 

    IA^ ia = b;

    IB^ ib = b;

    IC^ ic = b;

    b->funcIA();

    ia->funcIA();

    ib->funcIB();

    ic->funcIC();

    return 0;

}

#include "stdafx.h"

#include <iostream>

 

using namespace System;

 

ref class A {

public:

    static int a_;

    static A()

    {

        a_ += 10;

    }

};

ref class B {

public:

    static int b_;

    static B()

    {

//        a_ += 10; // error

        b_ += 10;

    }

};

ref class C {

public:

    static int c_ = 100;

    static C()

    {

        c_ = 10;

    }

};

 

int main()

{

    Console::WriteLine(A::a_);

    A::A();

    Console::WriteLine(A::a_);

 

    Console::WriteLine(B::b_);

 
    Console::WriteLine(C::c_);

     getchar();

    return 0;

}

ref class C

{

public:

    initonly static int x;

    initonly static int y;

    initonly int z;

    static C()

    {

        x = 1;

        y = 2;

        // z = 3; // Error

    }

    C()

    {

        // A = 2; // Error

        z = 3;

    }

    void sfunc()

    {

        // x = 5; // Error

        // z = 5; // Error

    }

};

int main()

{

    System::Console::WriteLine(C::x);

    System::Console::WriteLine(C::y);

    C c;

    System::Console::WriteLine(c.z);

    return 0;

}

using namespace System;

ref class C

{

public:

    literal String^ S = "Hello";

    literal int I = 100;

};

int main()

{

    Console::WriteLine(C::S);

    Console::WriteLine(C::I);

    return 0;

}

참고

http://cppcli.shacknet.nu/cli:static%E3%82%B3%E3%83%B3%E3%82%B9%E3%83%88%E3%83%A9%E3%82%AF%E3%82%BF

http://cppcli.shacknet.nu/cli:initonly

http://cppcli.shacknet.nu/cli:literal

void LOG( char* szText, ... )

{

}

void LOG( … array<Object^>^ Values )

{

for each( Object^ value in Values )

{

   ….

}

}

 

int main()

{

LOG( 23 );

LOG( 2, 1, “error” );

 

return 0;

}

void LOG( int nLogLevel, … array<Object^>^ Values )

{

}

#include "stdafx.h"

#include <iostream>

#include <vector>

#include <map>

 

using namespace std;

using namespace System;

using namespace System::Collections;

 

 

int main(array<System::String ^> ^args)

{

     // 배열

     array< int >^ Nums = { 0, 1, 2, 3, 4, 5 };

     for each(int value in Nums)

     {

          value = 2;

          Console::WriteLine( value );

     }

    // 위에서 for each 내부에서 요소의 값을 바꾸었지만 아래의 출력 값을 보면

    // 바뀌지 않은 것을 알 수 있습니다.

    for each(int value in Nums)

    {

          Console::WriteLine( value );

    }

 

   

    // 리스트

    ArrayList^ NumList = gcnew ArrayList();

    NumList->Add(1);

    NumList->Add(2);

    NumList->Add(3);

 

    for each(int value in NumList)

    {

        Console::WriteLine(value);

    }

 

 

    // vector

    vector<int> vi;

    vi.push_back(3);

    vi.push_back(4);

   

    for each(int i in vi)

    {

        Console::WriteLine(i);

    }

 

 

    // map

    map<const char*, int> num;

    num["ten"] = 10;

    num["hundred"] = 100;

 

    for each( pair<const char*, int> c in num )

    {

        Console::WriteLine(gcnew String(c.first) + c.second.ToString());

    }

 

 

    // 해쉬 테이블

    Hashtable^ ht = gcnew Hashtable();

    ht["aaa"] = "111";

    ht["bbb"] = "222";

    for each(DictionaryEntry^ dic in ht)

    {

        Console::WriteLine(dic->Key->ToString() + dic->Value->ToString());

    }

    

 

    getchar();

    return 0;

}

enum WEAPON_TYPE

{

GUN = 1,

SWORD = 2,

BOW = 3

};

int nUsedWeapon = GUN;

struct WEAPON

{

enum TYPE

{

GUN = 1,

SWORD = 2,

BOW = 3

};

};

 

int nUsedWeapon = WEAPON::GUN;

enum class WEAPON

{

   GUN = 1,

SWORD = 2,

BOW = 3

};

 

int nUsedWeapon = static_cast<int>(WEAPON::GUN);

enum class WEAPON : short

{

   GUN = 1,

SWORD = 2,

BOW = 3

};

public ref class WEAPON
{
public:
        literal short GUN = 1;
        literal short SWORD = 2;

        literal short BOW = 3;

};

delegate void ClickHandler();

ref class button {

public:

    event ClickHandler^ Clicked;

    button() {

        btnForTest = this;

    }

public:

    void someoneclicked() {

        Clicked();

    }

    static button^ btnForTest;

};

ref class Client {

private:

    button^ btn;

public:

    Client() {

        btn = gcnew button;

        btn->Clicked += gcnew ClickHandler(this, &Client::OnClick);

    }

private:

    void OnClick() {

        Console::WriteLine("someone clicked.");

    }

};

int main()

{

    Client^ client = gcnew Client;

    button::btnForTest->someoneclicked();

    return 0;

}

< 출처 : http://cppcli.shacknet.nu/cli:event >

event는 몇 개의 제약이 있습니다. 

1. Clicked 호출은 button 밖에 할 수 없습니다. 

2. 클라이언트가 Clicked에 대한 조작은 +=와 -=만 할 수 있으며 Clicked()나 Clicked = nullptr 같은 

것은 할 수 없습니다.

#include <iostream>

delegate void TestDelegate();

ref class TEST

{

public:

void TestMethod()

{

  System::Console::WriteLine(“TEST::TestMethod()”);

}

};

 

int main()

{

TEST^ test = gcnew TEST();

TestDelegate^ testDelegate = gcnew TestDelegate( test, &TEST::TestMethod );

 testDelegate();

 getchar();

    return 0;

};

#include <iostream>

 delegate void TestDelegate();

 ref class TEST

{

public:

static void TestMethod()

{

  System::Console::WriteLine(“TEST::TestMethod()”);

}

};

 

int main()

{

TestDelegate^ testDelegate = gcnew TestDelegate( &TEST::TestMethod );

 

testDelegate();

 

getchar();

return 0;

};

#include <iostream>

delegate void TestDelegate();

 

ref class TESTA

{

public:

void TestMethod()

{

  System::Console::WriteLine(“TESTA::TestMethod()”);

}

};

 

ref class TESTB

{

public:

static void TestMethod()

{

  System::Console::WriteLine(“TESTB::TestMethod()”);

}

};

 

ref class TESTC

{

public:

void operator()()

{

  System::Console::WriteLine(“TESTC::operator()”);

}

};

 

int main()

{

TestDelegate^ testDelegate;

TESTA testA;

TESTC testC;

 

testDelegate = gcnew TestDelegate( testA, &TESTA::TestMethod );

testDelegate += gcnew TestDelegate(&TESTB::TestMethod );

testDelegate += gcnew TestDelegate( testC, &TESTC::operator );

 

testDelegate();

 

getchar();

return 0;

};

using namespace System;

delegate void MyDele(int);

void func1(int i)

{

    Console::WriteLine("func1");

}

void func2(int j)

{

    Console::WriteLine("func2");

}

int main()

{

    MyDele^ dele;

    dele += gcnew MyDele(&func1);

    dele += gcnew MyDele(&func2);

    MyDele^ dele2 = gcnew MyDele(func1);

    dele2 += gcnew MyDele(&func2);

    if ( dele == dele2 )  {

        Console::WriteLine("TRUE");

    } else {

        Console::WriteLine("FALSE");

    }

   

    dele -= gcnew MyDele(&func1); 

   

    dele(1); 

   

   return 0;

}

#include "stdafx.h"

#include <iostream>

 

using namespace System;

 

delegate void MyDele(void);

 

void myfunc(void)

{

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

}

 

 

int main(array<System::String ^> ^args)

{

     MyDele^ dele = gcnew MyDele(&myfunc);

            Console::WriteLine(L"1");

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

            Console::WriteLine(L"2");

    dele->EndInvoke(result);

            Console::WriteLine(L"3");

   

    getchar();

    return 0;

}

class Character

{

public:

…….

   void SetCharCd( const int nCharCd ) { m_nCharCd = nCharCd; }

   int GetCharCd() { return m_nCharCd; }

…….

private:

   int m_nCharCd;

   …….

};