U.Seung's Log

    1 template<typename T>

    2 struct X

    3 {

    4     static void f(const T& t)

    5     {

    6         t.a = 100;

    7     }

    8 };

    9 struct S

   10 {

   11     int a;

   12 };

   13 

   14 int main(int argc, char* argv[])

   15 {

   16     S s;

   17     X<S>::f(s);

   18 

   16     S s;

   17     X<S&>::f(s);

   18 

   19     cout << s.a << endl;

    1 template<typename T>

    2 struct R

    3 {

    4     static void A(T&){}

    5     static void B(const T&){}

    6     static void C(T&&){}

    7     static void D(const T&&){}

    8 };

    9 

   10 {

   11     R<int&>::A(?)

   12     R<int&>::B(?)

   13     R<int&>::C(?)

   14     R<int&>::D(?)

   15 

   16     R<const int&>::A(?)

   17     R<const int&>::B(?)

   18     R<const int&>::C(?)

   19     R<const int&>::D(?)

   20 

   21     R<int&&>::A(?)

   22     R<int&&>::B(?)

   23     R<int&&>::C(?)

   24     R<int&&>::D(?)

   25 

   26     R<const int&&>::A(?)

   27     R<const int&&>::B(?)

   28     R<const int&&>::C(?)

   29     R<const int&&>::D(?)

   30 }

    1 int* pa = &a;

    2 const int* pb = &a;

    3 

    4 int fa() { return 1; }

    5 const int fb() { return 2; }

    6 

    7 int& fra() { return a; }

    8 const int& frb() { return b; }

    9 

   10 void main_rvalue()

   11 {

   12     RVALUE_CHECKER(1);

   13     RVALUE_CHECKER(int(1));

   14     RVALUE_CHECKER(new int(1));

   15     RVALUE_CHECKER(*(new int(1)));

   16 

   17     RVALUE_CHECKER(++a);

   18     RVALUE_CHECKER(a++);

   19     RVALUE_CHECKER(a + 1);

   20 

   21     RVALUE_CHECKER(++*pa);

   22     RVALUE_CHECKER(*pa++);

   23     RVALUE_CHECKER(*pa + 1);

   24 

   25     RVALUE_CHECKER(fa());

   26     RVALUE_CHECKER(fb());

   27 

   28     RVALUE_CHECKER(fra());

   29     RVALUE_CHECKER(frb());

   30 }

namespace NS

{

    bool Func(Arg* arg)

    {

        SomeGuard<Arg> RANDOM_NAME(arg);

        (...)

    }

    static Initialization RANDOM_NAME;

}

typedef function<void (void)> Closure;

void freef(int a, int b)

{

    cout << a << " + " << b << " = " << a+b << endl;

}

struct Class

{

    Class(int a): a_(a) {}

    void memf(int b)

    {

        cout << a_ << " - " << b << " = " << a_-b << endl;

    }

    int a_;

};

vector<Closure> closures;

{

    int a = 10;

    closures.push_back(bind(freef, a, 4));

    closures.push_back(bind(&Class::memf, new Class(a), 2));

//  closures.push_back([=](){ cout << a << endl; });

}

foreach(Closure& closure, closures)

{

    closure();

}

• 주로 I/O를 담당.
• Network 통신에 해당하는 Non-Blocking I/O와 Database 작업에 해당하는 Blocking I/O를 담당.
  (내부적으로는 위의 두가지 방식의 Thread Pool을 분리 한다고 함.)
• 채팅, 길드 등의 게임 로직을 담당

• 주로 (CPU작업이 많은) 게임로직을 담당.
• Blocking I/O만을 처리하며 모든 Thread가 대등한 역할을 수행.
• 대부분의 게임 로직을 처리하며, 통합 전장/Instance Dungeon 기능도 가짐.

서버 구조는 해당 게임의 특징에 따라서 다르겠지만 그것과 더불어서 해당 게임을 만드는 팀에 따라서 달라져야 합니다. 지금 만들고 있는 서버 구조는 현재 팀의 구성에 따라서 정한 것입니다. 만약 현재 팀 구성이 아니었다면 다른 모델을 도전 해볼 수도 있었을 것 같습니다.

set [ (999*999, 999, 999) ]

    |> Seq.unfold (fun pq ->

        let head = pq.MaximumElement

        let product, a, b = head

        let newElements =

            set [ ((a-1)*b, a-1, b); (a*(b-1), a, b-1) ]

                |> Set.filter (fun (_, a, b) -> a <= b)

        Some (product, ((pq.Remove head) + newElements)))

    |> Seq.filter is_parlindrome

    |> Seq.hd

    |> printfn "Problem #4 = %d"

let triangle_numbers =

    let rec triangle_number =

        function 0 -> 1 | n -> (n + 1 + triangle_number (n-1))

    Seq.init_infinite triangle_number

let triangle_numbers = Seq.unfold (fun (n, i) -> Some(n, (n+i, i+1))) (1, 2)

let triangle_numbers = Seq.init_infinite (fun n -> (n+2)*(n+1) / 2)

let factorize n =

    let rec factorize_horse n factor count result =

        if (n <= 1) then

            count::result

        else

            match (n % factor) with

            | 0 -> (factorize_horse (n/factor) factor (count+1) result)

            | _ -> (factorize_horse n (factor+1) 0 (count::result))          

    factorize_horse n 2 0 []

        |> List.filter (fun x -> x<>0)

let factor_count n =

    factorize n

        |> List.map (fun x -> x+1 )

        |> List.fold_left (*) 1

triangle_numbers

    |> Seq.filter (fun x -> 500 < (factor_count x))

    |> Seq.hd

    |> printfn "Problem #12 = %d"

open Microsoft.FSharp.Math

(BigInt.Factorial (BigInt 100)).ToString()

    |> Seq.map (fun x -> (int x) - (int '0'))

    |> Seq.sum

    |> printfn "Problem #20 = %d"