VioletaBabel

1350번: 진짜 공간

Beabletoet — Mon, 31 Dec 2018 21:17:09 +0900

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include<iostream>
#include<vector>
using namespace std;
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int n, clusterSize;
    long long int result = 0;
    vector<int> fileSize;
    cin >> n;
    for (int i = n, temp; i--; fileSize.push_back(temp))
        cin >> temp;
    cin >> clusterSize;
    for (int i = 0; i < n; ++i)
    {
        if (fileSize[i] == 0)
            continue;
        long long int t = fileSize[i] / clusterSize;
        if (fileSize[i] % clusterSize != 0)
            ++t;
        result += t * clusterSize;
    }
    cout << result;
}
Colored by Color Scripter
cs

2. 클래스

Beabletoet — Fri, 28 Dec 2018 12:44:13 +0900

클래스는 데이터(멤버 변수), 함수(메서드, 멤버 함수), 타입 정의, 포함된 다른 클래스 등을 가질 수 있다.

1. friend

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include<iostream>
using namespace std;
 
class one
{
public:
    one() { num = 100; }
    friend class two;
    void showNum() { cout << "one:" << num << endl; }
private:
    int num;
};
 
class two
{
public:
    two() { num = 0; }
    void getNum(one& o)
    {
        this->num += o.num;
        o.num = 0;
    }
    void showNum() { cout << "two:" << num << endl; }
private:
    int num;
};
 
int main()
{
    one o;
    two t;
    o.showNum(); // 100
    t.showNum(); // 0
    t.getNum(o);
    o.showNum(); // 0
    t.showNum(); // 100
}
Colored by Color Scripter
cs

friend를 이용하면 private에도 접근 가능하게 한다.

여기서 8번 줄의 friend class two; 를 주석처리하면 20,21번 줄의 o.num 에서 접근할 수 없다고 에러가 난다.

friend는 가능한 선언하지 않는 것이 좋다.

2. static

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include<iostream>
using namespace std;
 
class one
{
public:
    void showNum() { cout << num << endl; }
    void setNum(int value) { num = value; }
    int getNum() { return num; }
    static int num;
private:
};
 
int one::num; // static은 별도로 선언
 
int main()
{
    one o1, o2;
    o1.setNum(100);
    o1.showNum(); // 100
    o2.setNum(o1.getNum() + 100);
    o1.showNum(); // 200
    o2.showNum(); // 200
}
Colored by Color Scripter
cs

static은 공통으로 쓰는 것이라고 보면 된다.

싱글턴과도 일맥상통한다.

3. 생성자

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include<iostream>
using namespace std;
 
class one
{
public:
    int num1;
    int num2;
    one(int n1 = 0, int n2 = 0) 
    { // 생성자를 이용한 초기화
        num1 = n1; num2 = n2;
    }
    void showNum() { cout << num1 << "/" << num2 << endl; }
};
 
int main()
{
    one o1;
    one o2(1);
    one o3(2, 3);
    o1.showNum(); // 0/0
    o2.showNum(); // 1/0
    o3.showNum(); // 2/3
}
Colored by Color Scripter
cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
class one
{
public:
    one(int n1 = 0, int n2 = 0) : num1(n1), num2(n2) {} // 생성자를 이용한 초기화 2
    void showNum() { cout << num1 << "/" << num2 << endl; }
private:
    int num1;
    int num2;
};
 
int main()
{
    one o1;
    one o2(1);
    one o3(2, 3);
    o1.showNum(); // 0/0
    o2.showNum(); // 1/0
    o3.showNum(); // 2/3
 
    one o4(); //이건 함정. o4는 존재하지 않는다. 함수의 선언으로 해석하므로 ()에 주의.
}
Colored by Color Scripter
cs

멤버 초기화 리스트(또는 초기화 리스트)라고 부르는 방식이다.

생성자 함수의 머리 부분 다음에 콜론을 붙이고, 초기화 순서와 정의 순서를 일치하여 넣어야 한다.

여기서 주의할 점은 21번째 줄. 그 다음에 o4.showNum();이라고 할라손 치면 o4는 존재하지 않는다며 에러가 터진다.

1) 디폴트 생성자

인수가 없는 생성자거나, 모든 인수가 기본값을 갖는 생성자.

가능하다면 디폴트 생성자를 정의하는 것이 좋다.

하지만, 일부 클래스의 경우(멤버 중 일부가 레퍼런스라거나)에는 디폴트 생성자를 정의하는 것이 어려우므로 주의.

2) 복사 생성자

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include<iostream>
using namespace std;
 
class one
{
public:
    one(int n1 = 0, int n2 = 0) : num1(n1), num2(n2) {}
    one(const one& o) : num1(o.num1), num2(o.num2) {} // 복사 생성자
    void showNum() { cout << num1 << "/" << num2 << endl; }
    int num1;
    int num2;
};
 
int main()
{
    one o1(1, 2)
        , o2(o1)// o2는 복사 생성자
        , o3{ o1 }; // o3는 복사 생성자에다 C++11의 축소 방지를 추가
    o1.showNum(); // 1/2
    o2.showNum(); // 1/2
    o3.showNum(); // 1/2
}
Colored by Color Scripter
cs

복사 생성자를 사용할 때는 값에 의한 전달을 이용시 에러가 나며, 변경 가능한 레퍼런스로 사용하는 것을 비추천한다.

즉, const & 타입을 쓰는 것을 추천. 값으로 인수를 전달하려면 정의할 복사 생성자가 필요하므로 무한 루프에 빠진다(실제로는 막아놔서 에러만 뜬다).

디폴트 복사 생성자는 클래스에 포인터가 포함되는 경우 동작하지 않을 수 있다.

값이 아닌 주소를 복사해오므로 복사가 아닌 동시 참조가 되어버리는 탓.

만약 이런 문제를 막기 위해서면 클래스 안의 포인터를 unique_ptr로 하는 걸 추천한다.

메모리를 자동으로 해제할 뿐 아니라 복사 생성자가 자동으로 삭제되기 때문.

3) 변환과 명시적 생성자

C++에서는 암시적 생성자와 명시적 생성자를 구분한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include<iostream>
using namespace std;
 
class complex
{
public:
    double r;
    double i;
    complex(double nr = 0, double ni = 0.0) : r(nr), i(ni) {}
};
 
double real(complex c)
{
    return c.r;
}
 
double imag(complex c)
{
    return c.i;
}
 
double inline complex_abs(complex c)
{
    return sqrt(real(c)*real(c)*imag(c)*imag(c));
}
 
int main()
{
    cout << complex_abs(7.0) << endl;    // complex_abs함수에는 double을 인수로 받는 부분이 없는데도
                                        // double 타입을 허용하는 생성자가 있어서 암시적으로 생성해 처리
}
Colored by Color Scripter
cs

이런 암시적 생성자는 explicit으로 막을 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include<iostream>
using namespace std;
 
class complex
{
public:
    double r;
    double i;
    explicit complex(double nr = 0, double ni = 0.0) : r(nr), i(ni) {} // explicit
};
 
double real(complex c)
{
    return c.r;
}
 
double imag(complex c)
{
    return c.i;
}
 
double inline complex_abs(complex c)
{
    return sqrt(real(c)*real(c)*imag(c)*imag(c));
}
 
int main()
{
    cout << complex_abs(7.0) << endl;    // explicit이므로 에러!
}
Colored by Color Scripter
cs

explicit은 생성자의 암시적 변환을 비활성화한다.

4) 생성자 위임 (C++11)

C++03에서는 여러 생성자 오버로드를 함으로써 서로 중복된 코드를 가지고 있는 경우가 빈번했다.

그래서 C++11부터는 생성자가 다른 생성자를 호출하는 위임 기능을 제공한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<iostream>
using namespace std;
 
class one
{
public:
    int a;
    int b;
    one(int ta, int tb) : a{ ta }, b{ tb }{}
    one(int ta) : one{ ta,0 } {}
    one() : one{ 0,0 } {}
};
 
int main()
{
}
Colored by Color Scripter
cs

생성자를 위임하는 방식은 초기화가 더 복잡한 클래스일수록 더욱 유용하다.

5) 멤버의 기본값 (C++11)

그 외에도 멤버 변수의 기본값을 설정할 수 있는 기능이 나왔다.

이 기능을 이용해 생성자에서는 기본값과 다른 값이 들어가는 경우만 설정한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<iostream>
using namespace std;
 
class one
{
public:
    one(int ta, int tb) : a{ ta }, b{ tb }{}
    one(int ta) : a{ ta } {}
    one() {}
private:
    int a = 0;
    int b = 0;
};
 
int main()
{
}
Colored by Color Scripter
cs

4. 할당

(129p. 이 부분은 다시 볼 것. 뭐가 문제라는 건지 이해가 잘 안됨.)

5. 초기화 리스트 (C++11)

이건 멤버 초기화 리스트(위 3. 생성자에서 언급)와 별개임을 우선 명심하고 넘어가자.

클래스와 상관 없지만 후에 언급할 클래스의 유니폼 초기화 등에도 쓰일 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<iostream>
#include<initializer_list>
using namespace std;
 
int main()
{
    initializer_list<int> a{ 100,200,300,400 };
    for (int i : a)
        cout << i << " "; // 100 200 300 400
    cout << endl;
    a = { 10 };
    for (int i : a)
        cout << i << " "; // 10
}
Colored by Color Scripter
cs

다음과 같이 같은 타입의 값 목록으로 이루어진 것이 initializer list이다.

initializer_list를 인수로 둔 생성자를 이용해 다음과 같이 클래스에서 사용할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include<iostream>
#include<initializer_list>
using namespace std;
 
class one
{
public:
    one() :a{ 1 }, b{ 2 }{}
    one(initializer_list<int> values)
    {
        a = *(begin(values)); // 예전엔 values.begin()으로 사용
        b = *(begin(values) + 1);
    }
    void print() { cout << a << " " << b << endl; }
private:
    int a;
    int b;
};
int main()
{
    one o1;
    one o2 = { 2,3 }; // initializer_list를 인수로 가진 생성자를 거침
    o1.print(); // 1 2
    o2.print(); // 2 3
}
Colored by Color Scripter
cs

배열, 벡터 등을 이용한다면 std::copy 함수를 이용해 값을 복사할 수 있다.

그리고 begin, end 함수의 경우 c++11부터 자유 함수가 되었으며, 이전엔 주석과 같이 멤버 함수로 사용하였다.

6. 유니폼 초기화 (C++11)

1. C++ 기초

Beabletoet — Thu, 27 Dec 2018 12:31:07 +0900

1. 변수

기본 타입은 내장 타입(Intrinsic Type)이라고 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
#include<iostream>
using namespace std;
int main()
{
    int i1 = 2; // i1 = 2
    int i2, i3 = 5; // i2는 초기화 되지 않음, i3 = 5
    float pi = 3.14159; // pi = 3.14159
    double x = -1.5e6; // x = -1.5e+06 = -1500000
    double y = -1.5e-6; // y = -1.5e-06 = -0.0000015
    char c1 = 'a', c2 = 35; // c1 = a, c2 = #
    bool cmp = i1 < pi, happy = true; // cmp = 1, happy = 1 (1 = true)
    auto i4 = i3 + 7; //auto (C++11) : 변수의 타입을 추론한다. i4 = 12, type은 int.
}
Colored by Color Scripter
cs

auto는 C++11에 추가된 기능으로, 변수의 타입을 추론한다.

타입은 자동으로 정해지지만, 가능한 동일하게 유지한다.

2. 상수

문법적으로 불변이라는 추가 속성을 갖는 특별한 변수.

1
2
3
4
5
6
7
8
#include<iostream>
using namespace std;
int main()
{
    const int ci1 = 2;
    const float pi = 3.14159;
    const int ci3; // 값을 할당하지 않아 에러가 남
}
Colored by Color Scripter
cs

선언과 동시에 값을 설정해야 한다.

3. 리터럴

리터럴의 타입을 명시적(강제 변환)으로 선언할 필요는 없으나, 필요에 따라 다음과 같이 사용할 수 있다.

2 = int

2u = unsigned

2l = long

2ul = unsigned long

2.0 = double

2.0f = float

2.0l = long double

042 = 8진수 (0으로 시작하는 수는 8진수로 해석)

0x42 = 16진수 (0x, 0X라는 접두사를 붙이면 16진수)

0b42 = 2진수 (0b, 0B라는 접두사를 붙이면 2진수. C++14에 추가됨)

그리고 C++14부터 길이가 긴 리터럴의 가독성 향상을 위해 ' 로 숫자를 분리할 수 있다.

const long double pi = 3.141'592'653'589'793'238'462l;

문자열 리터럴은 char 배열로 할당한다.

그러나 string 타입을 더 추천하며, 매우 긴 텍스트는 다음 예제의 s3와 같이 부분 문자열로 분할 가능하다.

1
2
3
4
5
6
7
8
9
10
11
#include<iostream>
#include<string>
using namespace std;
int main()
{
    char s1[] = "Old C Style";
    string s2 = "In C++ better like this";
    string s3 = "This is a very long and clumsy text."
        "that is too long for one line.";
    cout << s1 << endl << s2 << endl << s3 << endl;
}
Colored by Color Scripter
cs

4. 축소하지 않는 초기화

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include<iostream>
using namespace std;
int main()
{
    long l2 = 1234567890123;            // 오버플로우로 값이 변함. l2 = 1912276171
    long l = { 1234567890123 };        // 값 보장이 안되므로 에러.
    long long l3 = { 1234567890123 };    // 값이 보장됨. l3 = 1234567890123
    int i1 = 3.14;                        // i1 = 3
    int i2 = { 3.14 };                // 소수 값 보장이 안되므로 에러.
    unsigned u2 = -3;                    // u2 = 4294967293
    unsigned u3 = { -3 };                // unsigned에 음수 값 보장 불가, 에러.
    float f1 = 3.14;                    // f1 = 3.14
    float f2 = { 3.14 };                // f2 = 3.14
    double d = 3.14;                    // d = 3.14
    float f3 = { d };                    // float에 double 값 보장 불가, 에러.
    unsigned u3 = { 3 };                // u3 = 3;
    int i2 = { 2 };                        // i2 = 2;
    unsigned u4 = { i2 };                // unsigned는 음수 값 보장 불가, 에러.
    int i3 = { u3 };                    // unsigned의 큰 값 보장 불가, 에러.
}
Colored by Color Scripter
cs

C++11부터 데이터가 손실되지 않음을 보장하기 위한 중괄호 초기화를 지원.

중괄호 초기화 시, 데이터를 보장할 수 없는 경우 에러가 난다.

5. 범위

전역 변수는 const같은 경우를 제외하고는 사용을 추천하지 않는다.

소프트웨어의 규모가 커짐에 따라 수정 사항을 추적하기 더 어려워지고 오류 사태를 촉발하게 되는 잠재력을 지녔기 때문.

지역 변수는 { } 괄호 안에서만 수명을 가진다. 그 밖에서는 존재하지 않는 것으로 친다.

만약 같은 이름의 변수가 중첩된 범위에 있으면 안쪽 범위의 변수는 바깥쪽 범위에 있는 동명의 변수를 숨긴다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<iostream>
using namespace std;
int main()
{
    int a = 5; // a(1) = 5
    {
        // a(1) = 5
        a = 3; // a(1) = 3
        int a = 8; // a(1) = 3 , a(2) = 8
        {
            a = 7; // a(1) = 3 , a(2) = 7
        }
        // a(1) = 3 , a(2) = 7
    }
    // a(1) = 3
    a = 1; // a(1) = 1
}
Colored by Color Scripter
cs

a(1)의 수명은 5번 줄부터 17번 줄 까지이고

a(2)의 수명은 9번 줄부터 14번 줄 까지이다.

범위는 충돌이 발생하지 않게 하지만, 바깥쪽 범위의 변수에게 접근하는 것을 막아버린다.

이를 해결할 방법은 이름을 바꾸거나, 네임스페이스를 이용하는 것이다.

6. 콤마 연산자

콤마 연산자는 왼쪽의 연산을 우선으로 시행한다.

주로 for문에서 사용.

1
2
3
4
5
6
7
#include<iostream>
using namespace std;
int main()
{
    int i1 = 3, i2 = 4, i3 = 9;
    cout << (i2 += i1, i2*i3); // 63이 출력
}
Colored by Color Scripter
cs

7. typeid 연산자

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<iostream>
using namespace std;
 
class Base{};
class Derived : public Base {};
 
int main()
{
    Derived* d = new Derived;
    Base* b = d;
    cout << typeid(b).name() << endl;
    cout << typeid(*b).name() << endl;
    cout << typeid(d).name() << endl;
    cout << typeid(*d).name() << endl;
}
Colored by Color Scripter
cs

런타임 타입을 식별하는 타입 식별자.

8. sizeof 연산자

1
2
3
4
5
6
7
8
9
10
#include<iostream>
using namespace std;
 
int main()
{
    int a = 4;
    cout << sizeof a << endl;
    cout << sizeof(a) << endl;
    cout << sizeof(long long) << endl;
}
Colored by Color Scripter
cs

타입이나 오브젝트의 크기

9. sizeof... 연산자

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<iostream>
using namespace std;
template<class... Types>
struct Count
{
    static const int value = sizeof...(Types);
};
int main()
{
    Count<int, char> a;
    cout << a.value << endl; // 2
    Count<int, int, int> b;
    cout << b.value << endl; // 3
}
Colored by Color Scripter
cs

C++11부터 도입된 연산자로 인수의 개수를 리턴하며, ...을 이용하는 variadic template에서만 사용할 수 있다.

10. alignof 연산자

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include<iostream>
using namespace std;
 
struct one {};
 
struct two
{
    int a;
    int b;
    char c;
};
 
int main()
{
    cout << alignof(one) << endl; // 1
    cout << alignof(two) << endl; // 4
    cout << alignof(int*) << endl; // 4
    cout << alignof(int) << endl; // 4
    cout << alignof(char*) << endl; // 4
    cout << alignof(char) << endl; // 1
}
Colored by Color Scripter
cs

C++11부터 도입된 연산자로, 타입이나 오브젝트의 메모리 맞춤을 리턴한다.

C++에서 구조체, 클래스는 정렬된 크기만큼 크기가 늘어나며, 크기가 그보다 작아도 padding으로 채워 그만큼의 크기를 잡는다.

alignof 연산자는 현재 정렬의 크기가 얼마인지를 리턴하는 셈.

11. 범위 기반 for문

C++11에 도입된 문법

1
2
3
4
5
6
7
8
9
#include<iostream>
using namespace std;
int main()
{
    int num[] = { 1,2,3,4,5,6,7,8,9,10 }, res = 0;
    for (int i : num)
        res += i;
    cout << res; // 55
}
Colored by Color Scripter
cs

타 언어의 foreach와 같은 거라고 보면 될 듯.

12. assert

c에서부터 이어져 내려오는 매크로.

표현식을 계산한 후 결과가 false면 프로그램을 즉시 종료한다.

1
2
3
4
5
6
7
8
9
10
#include<iostream>
#include<cassert>
using namespace std;
int main()
{
    int plusNum;
    cin >> plusNum;
    assert(plusNum > -1); // 음수를 입력 시 에러
    cout << plusNum;
}
Colored by Color Scripter
cs
양수 입력 시

음수 입력 시

13. 예외 처리

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<iostream>
using namespace std;
int main()
{//a/b, a%b 출력
    int a, b;
    cin >> a >> b;
    try 
    {
        if (b == 0)
            throw b;
        cout << a / b << endl << a % b << endl;
    }
    catch (int exception)
    {
        cerr << "b = 0" << endl;
        exit(EXIT_FAILURE); // 리턴 1과 같다고 보면 됨
    }
}
Colored by Color Scripter
cs

b에 0을 넣을 경우엔 바로 catch문의 항목을 실행.

그리고 C++11부터는 함수 뒤에 noexcept를 붙임으로서 예외를 던지지 않는 함수라고 지정하는 새로운 지정자 'noexcept'를 도입.

또, C++11부터 컴파일 과정에서 감지할 수 있는 프로그램 오류는 static_assert를 이용해 오류를 출력하고 컴파일을 중단하도록 함.

14. 서식 지정

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include<iostream>
#include<iomanip>
using namespace std;
int main()
{
    int old_precision = cout.precision();
    double pi = 3.141592653589793;
    cout << "1:" << pi << endl;
    cout << "2:" << setprecision(16) << pi << endl;
    cout << "3:" << setw(30) << pi << endl;
    cout << "4:" << right << setw(30) << pi << endl;
    cout << "5:" << setfill('-') << left << setw(30) << pi << endl;
    cout << "6:" << setfill('-') << right << setw(30) << pi << endl;
    cout.setf(ios_base::showpos);
    cout << "7:" << scientific << pi << endl;
    cout.unsetf(ios_base::adjustfield | ios_base::basefield | ios_base::floatfield | ios_base::showpos | ios_base::boolalpha);
    cout.precision(old_precision);
    cout << "8:" << oct << 63 << endl;
    cout << "9:" << hex << 63 << endl;
    cout << "10:" << dec << 63 << endl;
    cout << "11:" << (pi < 3) << endl;
    cout << "12:" << boolalpha << (pi < 3) << endl;
    cout << "13:" << noboolalpha << (pi < 3) << endl;
}
Colored by Color Scripter
cs

setprecision = 정밀도를 지정한다.

setw = 출력의 너비를 설정한다

right = 우측 정렬

left = 좌측 정렬

setfill = 특정 문자로 여백을 채운다

setf = 특정 서식 플래그를 직접 설정한다. showpos는 + - 부호를 보인다.

scientific = 과학적 표기법을 강제한다

oct = 8진수

hex = 16진수

dec = 10진수

boolalpha = bool값을 1,0이 아닌 true,false로 출력한다

unsetf = 특정 서식 플래그를 직접 해제한다.

15. 포인터

초기화하지 않은 포인터에는 무작위의 값이 할당되어있다.

포인터가 아무 것도 가리키고 있지 않다는 것을 명시적으로 알려주려면 다음과 같이 하면 된다.

이는 C++11 이상에서 사용하는 방법이다.

1
2
3
4
5
6
7
#include<iostream>
using namespace std;
int main()
{
    int* ip = nullptr;
    int* ip2{};
}
cs

그 외에도 이전 컴파일러에서 사용하던 다음과 같은 방법이 있지만, C++11 이상에서는 비추천한다.

1
2
3
4
5
6
7
#include<iostream>
using namespace std;
int main()
{
    int* ip = 0;
    int* ip2 = NULL;
}
cs

리터럴 0은 함수 오버로딩에서 모호함을 유발할 수 있고, NULL 매크로는 단지 0으로 치환될 뿐이므로 c++11이상에서는 nullptr이라는 포인터 리터럴의 키워드를 사용할 것을 추천한다.

포인터는 메모리 누수의 위험이 있다.

이를 예방하려는 전략을 소개한다.

1) 표준 컨테이너를 사용하라 : 표준 라이브러리나 유효성이 검증된 라이브러리는 메모리를 자동으로 해제해준다.

2) 캡슐화 : 개체를 소멸할 때 개체가 할당한 모든 메모리를 해제한다면 메모리 할당 빈도는 더 이상 중요하지 않다. 이러한 원칙을 RAII(Resource Acquisition Is Initialization)이라고 한다.

3) 스마트 포인터를 사용하라 : 포인터는 개체를 참조하고 동적 메모리를 관리하는 데에 사용한다. 소위 원시 포인터의 문제는 포인터가 데이터를 참조하고 있는지, 아니면 더 이상 필요하지 않은지에 대한 개념이 없다는 점이다. 그러므로 스마트 포인터를 사용할 수 있다.

16. 스마트 포인터

C++03에서 지원된 스마트 포인터 auto_ptr은 더는 사용하지 않을 것을 추천한다.

그 후 C++11에서 unique_ptr, shared_ptr, weak_ptr이라는 3가지 포인터를 도입했다.

1) unique_ptr : 이 포인터의 이름은 참조한 데이터의 고유 소유권을 나타낸다.

1
2
3
4
5
6
7
#include<iostream>
using namespace std;
int main()
{
    unique_ptr<double> d{ new double };
    *d = 10;
}
Colored by Color Scripter
cs

유니크포인터 d를 만들고 그 포인터가 가리키는 주소의 값에 10을 넣는다.

1
2
3
4
5
6
7
8
9
#include<iostream>
using namespace std;
int main()
{
    double a = 2;
    unique_ptr<double> d{ &a };
    *d = 10;
    cout << &a << endl << a << endl << d << endl << *d << endl;
}
Colored by Color Scripter
cs

유니크포인터 d를 만들고 거기에 a의 주소를 넣는다.

그 다음 d가 가리키는 주소의 값에 10을 넣으면 a도 10이 되어있다.

a의 주소와 d는 일치하며, 그러므로 a의 값과 d가 가리키는 주소의 값 역시 일치한다.

1
2
3
4
5
6
7
8
9
#include<iostream>
using namespace std;
int main()
{
    unique_ptr<double> d{ new double };
    *d = 10;
    double* raw = d.get();
    cout << *raw << endl; // 10
}
Colored by Color Scripter
cs

다른 원시 포인터에서 유니크포인터의 데이터를 얻으려면 멤버 함수 get을 이용한다.

1
2
3
4
5
6
7
8
9
#include<iostream>
using namespace std;
int main()
{
    unique_ptr<double> d{ new double };
    *d = 10;
    unique_ptr<double> d2{ d }; // 유니크포인터는 복사 금지라서 에러
    d2 = d; // 여기도 에러
}
Colored by Color Scripter


cs
유니크포인터는 다른 유니크포인터에 할당할 수 없다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<iostream>
using namespace std;
int main()
{
    unique_ptr<double> d{ new double };
    *d = 10;
    cout << *d << endl; // 10
    unique_ptr<double>d2{ move(d) }, d3;
    //cout << *d << endl; // d는 사용이 끝나 메모리가 해제되므로 에러.
    cout << *d2 << endl; // 10
    d3 = move(d2);
    //cout << *d2 << endl; // d2도 메모리가 해제. 에러.
    cout << *d3 << endl; // 10
}
Colored by Color Scripter
cs
유니크포인터는 복사가 아닌 이동만 가능.

기존의 포인터는 메모리가 해제됨.

1
2
3
4
5
6
7
8
9
10
11
#include<iostream>
using namespace std;
unique_ptr<double> uniqDouble()
{
    return unique_ptr<double>{new double};
}
int main()
{
    unique_ptr<double> d;
    d = uniqDouble();
}
Colored by Color Scripter
cs

이 경우는 함수의 결과는 이동될 임시 값이므로 move()가 없어도 됨.

배열은 이런식으로 사용

1
2
3
4
5
6
7
8
9
10
#include<iostream>
using namespace std;
int main()
{
    unique_ptr<double[]> da{ new double[3] };
    for (int i = 0; i < 3; ++i)
        da[i] = i + 1;
    for (int i = 0; i < 3; ++i)
        cout << da[i] << ' '; // 1 2 3 출력
}
Colored by Color Scripter
cs

대신 연산자 *는 배열에 사용 불가.

멤버 함수

get = 유니크포인터의 stored_ptr 반환

reset = 유니크포인터의 리소스를 해제하고 새 리소스를 넣음 // d.reset(new double);

release = 포인터의 해제 없이 소유권만 제거. 이런 경우 리턴된 포인터는 직접 해제하여야 함.

유니크포인터의 중요한 이점은 원시 포인터에 비해 시간과 메모리에 대한 오버헤드가 전혀 없다는 점.

2) shared_ptr

여러 파티가 각각 포인터를 가지고 있으며, 그 파티들이 공통으로 사용하는 메모리를 관리한다.

모든 스레드가 스레드의 접근이 끝나면 메모리를 자동으로 해제하는 속성이 있다.

참조 횟수라는 값을 두고, 참조할 때마다 1씩 증가, 수명이 다할 때마다 1씩 감소시키며 참조 횟수가 0이 되면 delete한다.

그리고 unique_ptr과 달리 원하는 만큼 자주 복사할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<iostream>
using namespace std;
shared_ptr<int> SharedInt()
{
    shared_ptr<int> p1{ new int };
    shared_ptr<int> p2{ new int }, p3 = p2;
    cout << "p3 : " << p3.use_count() << endl; // 2
    return p3;
}
int main()
{
    shared_ptr<int> p = SharedInt();
    cout << "p : " << p.use_count() << endl; // 1
}
Colored by Color Scripter
cs

함수가 반환하면 포인터를 파괴하고 p1이 참조하는 메모리를 해제한다.

p2, p3는 main의 p가 여전히 참조 중이기에 계속 존재한다.

그리고 make_shared를 이용해 보다 안전하게 만들 수도 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<iostream>
using namespace std;
shared_ptr<int> SharedInt()
{
    auto p1 = make_shared<int>();
    shared_ptr<int> p2 = make_shared<int>(), p3 = p2;
    cout << "p3 : " << p3.use_count() << endl; // 2
    return p3;
}
int main()
{
    shared_ptr<int> p = SharedInt();
    cout << "p : " << p.use_count() << endl; // 1
}
Colored by Color Scripter
cs

다음과 같이 auto를 사용할 수도 있다.

shared_ptr은 메모리와 실행 시간에 약간의 오버헤드를 가진다. 하지만 프로그램을 단순화할 수 있다는 이점이 있다.

하지만 메모리 해제를 방해하는 순환 참조 문제가 발생할 수 있다.

3) weak_ptr

weak_ptr은 위 shared_ptr의 순환 참조 문제를 중단할 수 있다.

공유하지만 소유권을 주장하지 않는다.

이 포인터는 나중에 다시 언급하기로 한다.

17. 배열용 컨테이너

1) vector

1
2
3
4
5
6
7
8
9
10
11
#include<iostream>
#include<vector>
using namespace std;
int main()
{
    vector<int> v(3), w(3);
    v = { 1,2,3 };
    w = { 7,8,9 };
    for (int i = 0; i < 3; ++i)
        cout << v[i] + w[i] << ' '; // 8 10 12
}
Colored by Color Scripter
cs

1
2
3
4
5
6
7
8
9
#include<iostream>
#include<vector>
using namespace std;
int main()
{
    vector<int> v = { 1,2,3 }, w = { 7,8,9 };
    for (int i = 0; i < 3; ++i)
        cout << v[i] + w[i] << ' '; // 8 10 12
}
Colored by Color Scripter
cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<iostream>
#include<vector>
#include<cassert>
using namespace std;
vector<int> add(const vector<int>& v1, const vector<int>& v2)
{
    assert(v1.size() == v2.size()); // 사이즈가 다르면 종료시킴
    vector<int> s(v1.size());
    for (int i = 0; i < v1.size(); ++i)
        s[i] = v1[i] + v2[i];
    return s;
}
int main()
{
    vector<int> v = { 1,2,3 }, w = { 7,8,9 }, s = add(v, w);
    for (int i = 0; i < 3; ++i)
        cout << s[i] << ' '; // 8 10 12
}
Colored by Color Scripter
cs

벡터는 자세한 설명은 생략한다.

2) valarray

요소별 연산을 사용하는 1차원 배열.

1
2
3
4
5
6
7
8
9
10
11
12
#include<iostream>
#include<valarray>
using namespace std;
int main()
{
    valarray<float> v = { 1,2,3 }, w = { 7,8,9 }, s = v + 2.0f * w, s2 = sin(s);
    for (float i : s)
        cout << i << ' '; // 15 18 21
    cout << endl;
    for (float i : s2)
        cout << i << ' '; // 0.650288 -0.750987 0.836656
}
Colored by Color Scripter
cs

각 요소 별로 연산을 수행한다.

슬라이스에 접근하는 기능이 강점이며, 각각의 연산을 포함해 행렬과 고차 텐서를 대리 실행할 수 있다.

허나 선형 대수 연산을 직접 지원하지 않는 편이라 valarray를 널리 사용하지는 않는다.

18. 포함방지 매크로

1
2
3
4
5
6
7
8
9
10
#include<iostream>
#ifndef MATH_FUNCTIONS_INCLUDE
#define MATH_FUNCTIONS_INCLUDE
#include<cmath>
#endif
using namespace std;
int main()
{
    
}
cs

간접적 포함으로 자주 사용하는 헤더 파일이 하나의 번역 단위에 여러번 들어가는 것을 막는 매크로.

일반적으로 _INCLUDE나 _HEADER를 끝에다가 붙인다.

편리하게 사용할 대안은 pragma once가 있다.

1
2
3
4
5
6
7
8
#include<iostream>
#pragma once
#include<cmath>
using namespace std;
int main()
{
    
}
cs

pragma once가 속도 등은 더 이점이 있지만, 구형 컴파일러에도 동작해야 한다면 ifndef~endif를 쓰는 것이 낫다.

버니 킹덤 점수 계산기 (미완)

Beabletoet — Sat, 22 Dec 2018 09:01:06 +0900

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
 
namespace BunnyKingdom
{
    /// <summary>
    /// MainWindow.xaml에 대한 상호 작용 논리
    /// </summary>
    public partial class MainWindow : Window
    {
        public enum ResourceType { none, wood, fish, carrot, rare };
        public enum Team { none, red, black, yellow, pink };
        int[] basicWood =
        {
            0, 1, 2, 7, 39
                , 40, 50, 53, 54, 58
                , 60, 79, 89, 90, 91
        };
        int[] basicFish =
        {
            4,5,6,9,13
                ,14,19,23,24,83
                ,84,93,94,98,99
        };
        int[] basicCarrot =
        {
            26,33,36,42,47
                ,56,66,71,73,95
        };
        int[] basicCastle =
        {
            3,12,16,18,20
                ,32,38,45,49,57
                ,61,64,68,72,76
                ,80,88,92
        };
        int[] rightMagma =
        {
            10,27,34,51
        };
        int[] downMagma =
        {
            15,21,86,87
        };
        public const int RED = 0;
        public const int BLACK = 1;
        public const int YELLOW = 2;
        public const int PINK = 3;
 
 
        public class selectData
        {
            public Team team = Team.none;
 
        }
        public class tileData
        {
            public int tileNum;
            public ResourceType basicResType = ResourceType.none;
            public ResourceType plusResType = ResourceType.none;
            public int up;
            public int down;
            public int left;
            public int right;
            public Team team = Team.none;
            public int castle = 0;
            public bool camp = false;
            public int sky = -1;
        }
        public selectData nowSelect = new selectData();
        public List<tileData> tileDataList = new List<tileData>();
        public List<Rectangle> mapList = new List<Rectangle>();
        public List<Label> labelList = new List<Label>();
        public bool[] mapCheckList = new bool[100];
        public MainWindow()
        {
            InitializeComponent();
            InitMapList();
        }
 
        public void InitMapList()
        {
            for (int i = 0; i < 100; ++i)
            {
                Rectangle r = new System.Windows.Shapes.Rectangle
                {
                    HorizontalAlignment = HorizontalAlignment.Left,
                    VerticalAlignment = VerticalAlignment.Top,
                    Height = 49,
                    Width = 49,
                    Margin = (new Thickness { Left = (double)(30 + (i % 10) * 50), Top = (double)(30 + (i / 10) * 50), Bottom = 0, Right = 0 }),
                    Fill = Brushes.LightGray,
                };
                this.myCanvas.Children.Add(r);
                mapList.Add(r);
 
                tileData t = new tileData
                {
                    tileNum = i,
                    up = i - 10,
                    left = i - 1,
                    right = i + 1,
                    down = i + 10,
                };
                tileDataList.Add(t);
 
                Label l = new Label
                {
                    FontSize = 20,
                    Height = 36,
                    Width = 31,
                    Margin = (new Thickness { Left = (double)(35 + (i % 10) * 50), Top = (double)(35 + (i / 10) * 50), Bottom = 0, Right = 0 }),
                    Content = "",
                };
                this.myCanvas.Children.Add(l);
                labelList.Add(l);
            }
            for (int i = 0; i < 18; ++i)
            {
                tileDataList[basicCastle[i]].castle = 1;
                labelList[basicCastle[i]].Content = "1";
                if (i > 14)
                    continue;
                tileDataList[basicFish[i]].basicResType = ResourceType.fish;
                tileDataList[basicWood[i]].basicResType = ResourceType.wood;
                if (i > 9)
                    continue;
                tileDataList[basicCarrot[i]].basicResType = ResourceType.carrot;
                tileDataList[i].up = -1;
                tileDataList[90 + i].down = -1;
                tileDataList[i * 10].left = -1;
                tileDataList[9 + i * 10].right = -1;
                if (i > 3)
                    continue;
                tileDataList[rightMagma[i]].right = -1;
                tileDataList[rightMagma[i] + 1].left = -1;
                tileDataList[downMagma[i]].down = -1;
                tileDataList[downMagma[i] + 10].up = -1;
            }
        }
 
 
        private void Window_MouseMove(object sender, MouseEventArgs e)
        {
 
        }
 
        private void Window_MouseDown(object sender, MouseButtonEventArgs e)
        {
            Point nowPos = e.GetPosition(myCanvas);
            if (nowPos.X >= 30 && nowPos.X <= 529 && nowPos.Y >= 30 && nowPos.Y <= 529)
            {
                /*
                30/30 ~ 79/79
                80/80 ~ 129/129
                480/480 ~ 529/529
                castle 1,2,3
                Fish
                Wood
                Carrot
                Rare
                camP
                Skytower
                 */
                System.Diagnostics.Debug.WriteLine(nowPos.X.ToString() + "/" + nowPos.Y.ToString());
                double x = (nowPos.X - 30) / 50, y = (nowPos.Y - 30) / 50;
                int num = (int)y * 10 + (int)x;
                if (tileDataList[num].camp || tileDataList[num].team.Equals(Team.none))
                    switch (nowSelect.team)
                    {
                        case Team.none:
                            mapList[num].Fill = Brushes.LightGray;
                            tileDataList[num].team = Team.none;
                            break;
                        case Team.red:
                            mapList[num].Fill = Brushes.Red;
                            tileDataList[num].team = Team.red;
                            break;
                        case Team.black:
                            mapList[num].Fill = Brushes.DarkGray;
                            tileDataList[num].team = Team.black;
                            break;
                        case Team.yellow:
                            mapList[num].Fill = Brushes.Yellow;
                            tileDataList[num].team = Team.yellow;
                            break;
                        case Team.pink:
                            mapList[num].Fill = Brushes.Pink;
                            tileDataList[num].team = Team.pink;
                            break;
                    }
            }
        }
 
        private void RadioButton_Checked(object sender, RoutedEventArgs e)
        {
            if (sender.ToString().Contains("Red"))
            {
                nowSelect.team = Team.red;
            }
            else if (sender.ToString().Contains("Black"))
            {
                nowSelect.team = Team.black;
            }
            else if (sender.ToString().Contains("Yellow"))
            {
                nowSelect.team = Team.yellow;
            }
            else if (sender.ToString().Contains("Pink"))
            {
                nowSelect.team = Team.pink;
            }
            else if (sender.ToString().Contains("None"))
            {
                nowSelect.team = Team.none;
            }
        }
 
        public class PlayerData
        {
            public int TotalPoint = 0;
            public int TopPoint = 0;
            public int Carrot = 0;
            public int Fish = 0;
            public int Wood = 0;
            public int Rare = 0;
            public int Castle = 0;
 
            public void InitData()
            {
                TotalPoint = 0;
                TopPoint = 0;
                Carrot = 0;
                Fish = 0;
                Wood = 0;
                Rare = 0;
                Castle = 0;
            }
 
            public void PlusData(int cursorPoint, int cursorCastleCount, int cursorWood, int cursorCarrot, int cursorFish, int cursorRare)
            {
                TotalPoint += cursorPoint;
                TopPoint = (TopPoint > cursorPoint) ? TopPoint : cursorPoint;
                Carrot += cursorCarrot;
                Fish += cursorFish;
                Wood += cursorWood;
                Rare += cursorRare;
                Castle += cursorCastleCount;
            }
        }
        PlayerData[] playerDatas = new PlayerData[4];
        int cursorCastle = 0, cursorRes = 0, cursorPoint = 0, cursorCastleCount = 0, cursorWood = 0, cursorCarrot = 0, cursorFish = 0, cursorRare = 0;
        Team cursor = Team.none;
        bool isWood = false, isCarrot = false, isFish = false;
 
        void InitCalculate()
        {
            for (int i = 0; i < 4; ++i)
            {
                if (playerDatas[i] == null)
                    playerDatas[i] = new PlayerData();
                playerDatas[i].InitData();
            }
            InitCalculateCursor();
        }
 
        void InitCalculateCursor()
        {
            cursor = Team.none;
            cursorPoint = 0;
            cursorCastle = 0;
            cursorRes = 0;
            cursorCastleCount = 0;
            cursorWood = 0;
            cursorCarrot = 0;
            cursorFish = 0;
            isWood = false;
            isCarrot = false;
            isFish = false;
        }
 
        private void Calculate_Click(object sender, RoutedEventArgs e)
        {
            for (int i = 0; i < 100; ++i)
                mapCheckList[i] = false;
 
            InitCalculate();
 
            for (int i = 0; i < 100; ++i)
            {
                DFS(i);
                if (cursor != Team.none)
                {
                    cursorPoint = cursorCastle * cursorRes;
                    int teamNum = -1;
                    switch (cursor)
                    {
                        case Team.red:
                            teamNum = RED;
                            break;
                        case Team.black:
                            teamNum = BLACK;
                            break;
                        case Team.yellow:
                            teamNum = YELLOW;
                            break;
                        case Team.pink:
                            teamNum = PINK;
                            break;
                    }
                    if (teamNum != -1)
                    {
                        playerDatas[teamNum].PlusData(cursorPoint, cursorCastleCount, cursorWood, cursorCarrot, cursorFish, cursorRare);
                    }
                }
                InitCalculateCursor();
            }
            ShowingPoint();
        }
 
        void ShowingPoint()
        {
            Red_TopPoint.Content = playerDatas[RED].TopPoint.ToString();
            Red_TotalPoint.Content = playerDatas[RED].TotalPoint.ToString();
            Red_Carrot.Content = playerDatas[RED].Carrot.ToString();
            Red_Castle.Content = playerDatas[RED].Castle.ToString();
            Red_Fish.Content = playerDatas[RED].Fish.ToString();
            Red_Rare.Content = playerDatas[RED].Rare.ToString();
            Red_Wood.Content = playerDatas[RED].Wood.ToString();
 
            Black_TopPoint.Content = playerDatas[BLACK].TopPoint.ToString();
            Black_TotalPoint.Content = playerDatas[BLACK].TotalPoint.ToString();
            Black_Carrot.Content = playerDatas[BLACK].Carrot.ToString();
            Black_Castle.Content = playerDatas[BLACK].Castle.ToString();
            Black_Fish.Content = playerDatas[BLACK].Fish.ToString();
            Black_Rare.Content = playerDatas[BLACK].Rare.ToString();
            Black_Wood.Content = playerDatas[BLACK].Wood.ToString();
 
            Yellow_TopPoint.Content = playerDatas[YELLOW].TopPoint.ToString();
            Yellow_TotalPoint.Content = playerDatas[YELLOW].TotalPoint.ToString();
            Yellow_Carrot.Content = playerDatas[YELLOW].Carrot.ToString();
            Yellow_Castle.Content = playerDatas[YELLOW].Castle.ToString();
            Yellow_Fish.Content = playerDatas[YELLOW].Fish.ToString();
            Yellow_Rare.Content = playerDatas[YELLOW].Rare.ToString();
            Yellow_Wood.Content = playerDatas[YELLOW].Wood.ToString();
 
            Pink_TopPoint.Content = playerDatas[PINK].TopPoint.ToString();
            Pink_TotalPoint.Content = playerDatas[PINK].TotalPoint.ToString();
            Pink_Carrot.Content = playerDatas[PINK].Carrot.ToString();
            Pink_Castle.Content = playerDatas[PINK].Castle.ToString();
            Pink_Fish.Content = playerDatas[PINK].Fish.ToString();
            Pink_Rare.Content = playerDatas[PINK].Rare.ToString();
            Pink_Wood.Content = playerDatas[PINK].Wood.ToString();
        }
 
        void DFS(int i)
        {
            if (!mapCheckList[i])
            {//이미 검사한 맵인가
                mapCheckList[i] = true;
                if (tileDataList[i].team != Team.none)
                {//이미 누가 점령중인 맵인가
                    if (cursor == Team.none)//커서에 저장할 애는 저장한다
                        cursor = tileDataList[i].team;
 
                    if (cursor == tileDataList[i].team)
                    {//현재 커서와 같은 팀 아이인지 확인한다
                        switch (tileDataList[i].basicResType)
                        {//기본 자원을 검사해 넣는다
                            case ResourceType.carrot:
                                ++cursorCarrot;
                                if (!isCarrot)
                                {
                                    isCarrot = true;
                                    ++cursorRes;
                                }
                                break;
                            case ResourceType.fish:
                                ++cursorFish;
                                if (!isFish)
                                {
                                    isFish = true;
                                    ++cursorRes;
                                }
                                break;
                            case ResourceType.wood:
                                ++cursorWood;
                                if (!isWood)
                                {
                                    isWood = true;
                                    ++cursorRes;
                                }
                                break;
                        }
 
                        switch (tileDataList[i].plusResType)
                        {//추가 건물 자원을 검사해 넣는다
                            case ResourceType.rare:
                                ++cursorRare;
                                ++cursorRes;
                                break;
                            case ResourceType.carrot:
                                ++cursorCarrot;
                                if (!isCarrot)
                                {
                                    isCarrot = true;
                                    ++cursorRes;
                                }
                                break;
                            case ResourceType.fish:
                                ++cursorFish;
                                if (!isFish)
                                {
                                    isFish = true;
                                    ++cursorRes;
                                }
                                break;
                            case ResourceType.wood:
                                ++cursorWood;
                                if (!isWood)
                                {
                                    isWood = true;
                                    ++cursorRes;
                                }
                                break;
                        }
 
                        if (tileDataList[i].castle > 0)
                        {
                            cursorCastle += tileDataList[i].castle;
                            ++cursorCastleCount;
                        }
                        if (tileDataList[i].sky != -1)
                            DFS(tileDataList[i].sky);
                        if (tileDataList[i].up != -1)
                            DFS(tileDataList[i].up);
                        if (tileDataList[i].down != -1)
                            DFS(tileDataList[i].down);
                        if (tileDataList[i].left != -1)
                            DFS(tileDataList[i].left);
                        if (tileDataList[i].right != -1)
                            DFS(tileDataList[i].right);
                    }
                    else
                    {
                        mapCheckList[i] = false;
                    }
 
 
                }
            }
        }
    }
}
Colored by Color Scripter
cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
<Window x:Class="BunnyKingdom.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:BunnyKingdom"
        mc:Ignorable="d"
        MouseMove="Window_MouseMove" MouseDown="Window_MouseDown"
        Title="MainWindow" Height="720" Width="1280">
    <Grid>
        <Canvas x:Name="myCanvas" HorizontalAlignment=" Left" VerticalAlignment="Top" Width="1280" Height="720" Margin="0,0,-8,-30">
            <Label Content="A" Canvas.Top="35" Width="30" Height="40" FontSize="20" Canvas.Left="10"/>
            <Label Content="B" Canvas.Top="85" Width="30" Height="40" FontSize="20" Canvas.Left="10"/>
            <Label Content="C" Canvas.Top="135" Width="30" Height="40" FontSize="20" Canvas.Left="10"/>
            <Label Content="D" Canvas.Top="185" Width="30" Height="40" FontSize="20" Canvas.Left="10"/>
            <Label Content="E" Canvas.Top="235" Width="30" Height="40" FontSize="20" Canvas.Left="10"/>
            <Label Content="F" Canvas.Top="285" Width="30" Height="40" FontSize="20" Canvas.Left="10"/>
            <Label Content="G" Canvas.Top="335" Width="30" Height="40" FontSize="20" Canvas.Left="10"/>
            <Label Content="H" Canvas.Top="385" Width="30" Height="40" FontSize="20" Canvas.Left="10"/>
            <Label Content="I" Canvas.Top="435" Width="30" Height="40" FontSize="20" Canvas.Left="10"/>
            <Label Content="J" Canvas.Top="485" Width="30" Height="40" FontSize="20" Canvas.Left="10"/>
            <Label Content="1" Width="31" Height="36" FontSize="20" Canvas.Left="45"/>
            <Label Content="2" Width="31" Height="36" FontSize="20" Canvas.Left="95"/>
            <Label Content="3" Width="31" Height="36" FontSize="20" Canvas.Left="145"/>
            <Label Content="4" Width="31" Height="36" FontSize="20" Canvas.Left="195"/>
            <Label Content="5" Width="31" Height="36" FontSize="20" Canvas.Left="245"/>
            <Label Content="6" Width="31" Height="36" FontSize="20" Canvas.Left="295"/>
            <Label Content="7" Width="31" Height="36" FontSize="20" Canvas.Left="345"/>
            <Label Content="8" Width="31" Height="36" FontSize="20" Canvas.Left="395"/>
            <Label Content="9" Width="31" Height="36" FontSize="20" Canvas.Left="445"/>
            <Label Content="10" Width="31" Height="36" FontSize="20" Canvas.Left="490"/>
            <Label Content="1" Width="31" Height="36" FontSize="20" Margin="35,35,0,0"/>
 
            <Label Content="Team Color(Mouse LeftButton)" Canvas.Left="594" Canvas.Top="10"/>
            <RadioButton x:Name="Team_None"   GroupName="Team" Content="None"   Canvas.Left="594" Canvas.Top="40"  Checked="RadioButton_Checked" IsChecked="True"/>
            <RadioButton x:Name="Team_Red"    GroupName="Team" Content="Red"    Canvas.Left="594" Canvas.Top="55"  Checked="RadioButton_Checked"/>
            <RadioButton x:Name="Team_Black"  GroupName="Team" Content="Black"  Canvas.Left="594" Canvas.Top="70"  Checked="RadioButton_Checked"/>
            <RadioButton x:Name="Team_Yellow" GroupName="Team" Content="Yellow" Canvas.Left="594" Canvas.Top="85"  Checked="RadioButton_Checked"/>
            <RadioButton x:Name="Team_Pink"   GroupName="Team" Content="Pink"   Canvas.Left="594" Canvas.Top="100" Checked="RadioButton_Checked"/>
 
            <Button Content="Calculate" Canvas.Left="800" Canvas.Top="150" Width="75" Click="Calculate_Click"/>
            <Label Content="Red" Canvas.Left="700" Canvas.Top="185"/>
            <Label Content="Black" Canvas.Left="950" Canvas.Top="185"/>
            <Label Content="Yellow" Canvas.Left="700" Canvas.Top="425"/>
            <Label Content="Pink" Canvas.Left="950" Canvas.Top="425"/>
            <Label Content="TotalPoint" Canvas.Left="700" Canvas.Top="200"/>
            <Label Content="TotalPoint" Canvas.Left="950" Canvas.Top="200"/>
            <Label Content="TotalPoint" Canvas.Left="700" Canvas.Top="440"/>
            <Label Content="TotalPoint" Canvas.Left="950" Canvas.Top="440"/>
            <Label x:Name="Red_TotalPoint" Content="0" Canvas.Left="800" Canvas.Top="200"/>
            <Label x:Name="Black_TotalPoint" Content="0" Canvas.Left="1050" Canvas.Top="200"/>
            <Label x:Name="Yellow_TotalPoint" Content="0" Canvas.Left="800" Canvas.Top="440"/>
            <Label x:Name="Pink_TotalPoint" Content="0" Canvas.Left="1050" Canvas.Top="440"/>
            <Label Content="TopPoint" Canvas.Left="700" Canvas.Top="215"/>
            <Label Content="TopPoint" Canvas.Left="950" Canvas.Top="215"/>
            <Label Content="TopPoint" Canvas.Left="700" Canvas.Top="455"/>
            <Label Content="TopPoint" Canvas.Left="950" Canvas.Top="455"/>
            <Label x:Name="Red_TopPoint" Content="0" Canvas.Left="800" Canvas.Top="215"/>
            <Label x:Name="Black_TopPoint" Content="0" Canvas.Left="1050" Canvas.Top="215"/>
            <Label x:Name="Yellow_TopPoint" Content="0" Canvas.Left="800" Canvas.Top="455"/>
            <Label x:Name="Pink_TopPoint" Content="0" Canvas.Left="1050" Canvas.Top="455"/>
            <Label Content="Wood" Canvas.Left="700" Canvas.Top="230"/>
            <Label Content="Wood" Canvas.Left="950" Canvas.Top="230"/>
            <Label Content="Wood" Canvas.Left="700" Canvas.Top="470"/>
            <Label Content="Wood" Canvas.Left="950" Canvas.Top="470"/>
            <Label    x:Name="Red_Wood" Content="0" Canvas.Left="800"  Canvas.Top="230"/>
            <Label  x:Name="Black_Wood" Content="0" Canvas.Left="1050" Canvas.Top="230"/>
            <Label x:Name="Yellow_Wood" Content="0" Canvas.Left="800"  Canvas.Top="470"/>
            <Label   x:Name="Pink_Wood" Content="0" Canvas.Left="1050" Canvas.Top="470"/>
            <Label       Content="Carrot" Canvas.Left="700"              Canvas.Top="245"/>
            <Label       Content="Carrot" Canvas.Left="950"              Canvas.Top="245"/>
            <Label    x:Name="Red_Carrot" Content="0" Canvas.Left="800"  Canvas.Top="245"/>
            <Label  x:Name="Black_Carrot" Content="0" Canvas.Left="1050" Canvas.Top="245"/>
            <Label       Content="Carrot" Canvas.Left="700"              Canvas.Top="485"/>
            <Label       Content="Carrot" Canvas.Left="950"              Canvas.Top="485"/>
            <Label x:Name="Yellow_Carrot" Content="0" Canvas.Left="800"  Canvas.Top="485"/>
            <Label   x:Name="Pink_Carrot" Content="0" Canvas.Left="1050" Canvas.Top="485"/>
            <Label       Content="Fish" Canvas.Left="700"              Canvas.Top="260"/>
            <Label       Content="Fish" Canvas.Left="950"              Canvas.Top="260"/>
            <Label    x:Name="Red_Fish" Content="0" Canvas.Left="800"  Canvas.Top="260"/>
            <Label  x:Name="Black_Fish" Content="0" Canvas.Left="1050" Canvas.Top="260"/>
            <Label       Content="Fish" Canvas.Left="700"              Canvas.Top="500"/>
            <Label       Content="Fish" Canvas.Left="950"              Canvas.Top="500"/>
            <Label x:Name="Yellow_Fish" Content="0" Canvas.Left="800"  Canvas.Top="500"/>
            <Label   x:Name="Pink_Fish" Content="0" Canvas.Left="1050" Canvas.Top="500"/>
            <Label       Content="Rare" Canvas.Left="700"              Canvas.Top="275"/>
            <Label       Content="Rare" Canvas.Left="950"              Canvas.Top="275"/>
            <Label    x:Name="Red_Rare" Content="0" Canvas.Left="800"  Canvas.Top="275"/>
            <Label  x:Name="Black_Rare" Content="0" Canvas.Left="1050" Canvas.Top="275"/>
            <Label       Content="Rare" Canvas.Left="700"              Canvas.Top="515"/>
            <Label       Content="Rare" Canvas.Left="950"              Canvas.Top="515"/>
            <Label x:Name="Yellow_Rare" Content="0" Canvas.Left="800"  Canvas.Top="515"/>
            <Label   x:Name="Pink_Rare" Content="0" Canvas.Left="1050" Canvas.Top="515"/>
            <Label       Content="Castle" Canvas.Left="700"              Canvas.Top="290"/>
            <Label       Content="Castle" Canvas.Left="950"              Canvas.Top="290"/>
            <Label    x:Name="Red_Castle" Content="0" Canvas.Left="800"  Canvas.Top="290"/>
            <Label  x:Name="Black_Castle" Content="0" Canvas.Left="1050" Canvas.Top="290"/>
            <Label       Content="Castle" Canvas.Left="700"              Canvas.Top="530"/>
            <Label       Content="Castle" Canvas.Left="950"              Canvas.Top="530"/>
            <Label x:Name="Yellow_Castle" Content="0" Canvas.Left="800"  Canvas.Top="530"/>
            <Label   x:Name="Pink_Castle" Content="0" Canvas.Left="1050" Canvas.Top="530"/>
        </Canvas>
    </Grid>
</Window>
 
Colored by Color Scripter
cs

15953번: 상금 헌터

Beabletoet — Mon, 10 Dec 2018 13:42:16 +0900

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include<cstdio>
int main()
{
    int price1[6] = { 5000000,3000000,2000000,500000,300000,100000 }, t, a, b, res = 0;
    for (scanf("%d", &t); t--; printf("%d\n", res))
    {
        res = 0;
        scanf("%d %d", &a, &b);
        if (a > 0)
        {
            for (int i = 0; ++i < 7;)
            {
                a -= i;
                if (a < 1)
                {
                    res += price1[i - 1];
                    break;
                }
            }
        }
        if (b > 0)
        {
            int res2 = 5120000;
            for (int i = 1; i < 32; i *= 2, res2 /= 2)
            {
                b -= i;
                if (b < 1)
                {
                    res += res2;
                    break;
                }
            }
        }
    }
}
Colored by Color Scripter
cs

1212번: 8진수 2진수

Beabletoet — Thu, 6 Dec 2018 15:00:49 +0900

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include<iostream>
#include<string>
using namespace std;
int main()
{
    string oct;
    cin >> oct;
    if (oct == "0")
    {
        cout << oct;
        return 0;
    }
    bool isFirst = true;
    for (int i = 0, len = oct.length(); i < len; ++i)
    {
        int t = (int)oct[i] - '0';
        for (int j = 4; j; t %= j, j /= 2)
        {
            if (isFirst)
                if (t / j == 0)
                    continue;
            cout << t / j;
            if (isFirst)
                isFirst = false;
        }
    }
}
Colored by Color Scripter
cs

1145번: 적어도 대부분의 배수

Beabletoet — Thu, 6 Dec 2018 13:20:43 +0900

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include<cstdio>
using namespace std;
int LCM(int a, int b)
{
    int t = a * b;
    for (int temp; a%b != 0; b = temp % b)
    {
        temp = a;
        a = b;
    }
    return t / b;
}
int main()
{
    int num[5];
    int best = 1000000;
    for (int i = 5; i--; scanf("%d", num + i));
    for (int i = 0; i < 3; ++i)
    {
        for (int j = i + 1; j < 4; ++j)
        {
            for (int k = j + 1; k < 5; ++k)
            {
                int t = LCM(num[i], LCM(num[j], num[k]));
                best = (t < best) ? t : best;
            }
        }
    }
    printf("%d", best);
}
Colored by Color Scripter
cs

원형 큐 (c/c++)

Beabletoet — Thu, 6 Dec 2018 11:15:14 +0900

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#include<cstdio>
using namespace std;
 
struct node
{
    node* prev;
    node* next;
    int value;
};
 
class CircleList
{
private:
    node head;
public:
    void Add(int i);
    void Remove(int i);
    void LinkNewNode(node *t, node *newer, node *h);
    void ShowAllNumber();
    CircleList();
    int count;
};
 
void CircleList::Add(int i)
{
    node *newer = new node;
    if (count > 0)
    {
        LinkNewNode(head.next->prev, newer, head.next);
        newer->value = i;
    }
    else
    {
        head.next = newer;
        head.prev = newer;
        newer->prev = newer;
        newer->next = newer;
        newer->value = i;
    }
    ++count;
}
 
void CircleList::Remove(int i)
{//i와 동일한 밸류를 처음 찾으면, 그 애를 삭제
    node *cursor = head.next;
    if (count > 1)
    {
        do
        {
            if (cursor->value == i)
            {
                node *n = cursor->next;
                node *p = cursor->prev;
                p->next = n;
                n->prev = p;
                if (head.next == cursor)
                {
                    head.next = n;
                    head.prev = n;
                }
                delete cursor;
                --count;
                break;
            }
            cursor = cursor->next;
        } while (cursor != head.next);
    }
    else if (count > 0)
    {
        cursor = head.next;
        if (cursor->value == i)
        {
            head.next = &head;
            head.prev = &head;
            delete cursor;
            --count;
        }
    }
}
 
void CircleList::LinkNewNode(node *t, node *newer, node *h)
{
    (*newer).prev = t;
    (*newer).next = h;
    (*t).next = newer;
    (*h).prev = newer;
}
 
void CircleList::ShowAllNumber()
{
    printf("count : %d\n", count);
    if (count > 0)
    {
        node* cursor;
        cursor = head.next;
        do
        {
            printf("%d %d %d\n", cursor->prev->value, cursor->value, cursor->next->value);
            cursor = cursor->next;
        } while (cursor != head.next);
    }
}
 
CircleList::CircleList()
{
    head.prev = &head;
    head.next = &head;
    head.value = 0;
    count = 0;
}
Colored by Color Scripter
cs

[강연] 혼자서 성장하기

Beabletoet — Tue, 4 Dec 2018 16:57:24 +0900

[강연] 혼자서 성장하기
 - 업계 동향 파악 : 개발자 커뮤니티 눈팅
게임코디 (현업자만 가입 가능)
스마트폰게임개발자그룹 (페이스북 그룹, 홍보가 많다)
안드로이드펍
유니티허브 카페
인디개발자쉼터(인디터)
인디라 페이스북 그룹
생활코딩
유니티 코리아 페이스북
okky
 - 개발자모임
다른 개발사에 근무하고 있는 지인들과의 만남
인디라등 오프라인 만남
 - 유튜브 등 동영상
유튜브에 키워드를 치면 요즘은 많이들 나옴.
 - 코드 리뷰
git 사용 현황 확인(commit, merge 현황)
현재 작업중인 사항에 대해 논의

1021번: 회전하는 큐

Beabletoet — Tue, 4 Dec 2018 15:52:06 +0900

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include<cstdio>
#include<queue>
using namespace std;
int checkQueue(queue<int> *q, queue<int> *gacha);
void reverseQueue(queue<int> *q);
int main()
{
    queue<int> q1, q2, gachaNumbers;
    int qSize, gachaCount, result = 0;
    scanf("%d %d", &qSize, &gachaCount);
    for (int i = 0; i < gachaCount; ++i)
    {
        int t;
        scanf("%d", &t);
        gachaNumbers.push(t);
    }
    q2.push(1);
    for (int i = 0; ++i <= qSize; q1.push(i));
    for (int i = qSize; i > 1; q2.push(i--));
 
    while (gachaCount--)
    {
        int qNum1 = checkQueue(&q1, &gachaNumbers);
        int qNum2 = checkQueue(&q2, &gachaNumbers);
        result += ((qNum1 < qNum2) ? qNum1 : qNum2);
        gachaNumbers.pop();
        reverseQueue(&q2);
    }
    printf("%d", result);
    return 0;
}
 
int checkQueue(queue<int> *q, queue<int> *gacha)
{
    int tempNum = 0;
    while (true)
    {
        if ((*q).front() == (*gacha).front())
        {
            (*q).pop();
            break;
        }
        ++tempNum;
        (*q).push((*q).front());
        (*q).pop();
    }
    return tempNum;
}
 
void reverseQueue(queue<int> *q)
{
    for (int i = 0; i < (*q).size() - 1; ++i)
    {
        (*q).push((*q).front());
        (*q).pop();
    }
}
Colored by Color Scripter
cs

무식하지만 큐 두개로 회전시킨 코드.

실제로 돌리면 안되겠구나.

그래서 데크로 다시 짬

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include<deque>
#include<cstdio>
using namespace std;
int main()
{
    deque<int> left, right;
    int n, m, result = 0;
    scanf("%d %d", &n, &m);
    for (int i = 0; i++ < n; left.push_back(i), right.push_back(i));
    for (int tmp; m--;)
    {
        scanf("%d", &tmp);
        int lRes = 0, rRes = 0;
        while (left.front() != tmp)
        {
            ++lRes;
            left.push_back(left.front());
            left.pop_front();
        }
        while (right.front() != tmp)
        {
            ++rRes;
            right.push_front(right.back());
            right.pop_back();
        }
        left.pop_front();
        right.pop_front();
        result += (lRes < rRes) ? lRes : rRes;
    }
    printf("%d", result);
}
Colored by Color Scripter
cs