1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#define N 12
 
int n;
int dp[N + 1];
 
int main()
{
    scanf("%d", &n);
 
    // dp[n] = (n - 1) * (dp[n - 2] + dp[n - 1])
 
    dp[2] = 1;
    for (int i = 3; i <= N; i++)
        dp[i] = (i - 1) * (dp[i - 2] + dp[i - 1]);
 
    printf("%d\n", dp[n]);
 
    return 0;
}
cs


저작자표시




저작자표시

Chapter 01 C언어 기반의 C++


01-1. printf와 scanf를 대신하는 입출력 방식


- printf 대신 cout, scanf 대신 cin을 사용한다.

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
 
int main()
{
    int num = 20;
    std::cout << "Hello World!" << std::endl;
    std::cout << "Hello " << "World!" << std::endl;
    std::cout << num << ' ' << 'A';
    std::cout << ' ' << 3.14 << std::endl;
    return 0;
}
cs



01-2 함수오버로딩


- 함수의 매개변수의 자료형 또는 개수가 다를 때, 동일한 이름의 함수정의를 허용하는 것을 말한다.

- 함수 오버로딩이 가능 하려면 매개변수의 자료형 또는 개수가 달라야 한다.



01-3 매개변수의 디폴트 값


- 매개변수에 디폴트 값이 설정되어 있으면, 함수호출 시 인자를 전달하지 않으면 디폴트 값이 전달된다.

- 매개변수에 디폴트 값이 설정되어 있으면, 선언된 매개변수의 수보다 적은 수의 인자전달이 가능하다. 그리고 전달되는 인자는 왼쪽에서부터 채워져 나가고, 부족분은 디폴트 값으로 채워진다.

- 함수의 원형을 별도로 선언하는 경우, 매개변수의 디폴트 값은 함수의 원형 선언에만 위치시켜야 한다.

- 일부분만 디폴트 값을 지정할 수도 있다. 하지만 반드시 오른쪽 매개변수의 디폴트 값부터 채우는 형태로 정의해야 한다.


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 BoxVolume(int length, int width = 1, int height = 1);    
 
int main()
{
    cout << "[3, 3, 3] : " << BoxVolume(3, 3, 3) << endl;
    cout << "[5, 5, D]" << BoxVolume(5, 5) << endl;
    cout << "[7,D,D]" << BoxVolume(7) << endl;
//    cout << "[D,D,D]" << BoxVolume() << endl;    // 모든 매개변수에 디폴트 값이 지정된 것이 아니므로, 에러
    return 0;
}
 
int BoxVolume(int length, int width, int height)
{
    return length * width * height;
}
cs


1-4 인라인(inline) 함수


1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream>
 
inline int SQUARE(int x)
{
    return x * x;
}
 
int main()
{
    std::cout << SQUARE(5) << std::endl;
    std::cout << SQUARE(12) << std::endl;
    return 0;
}
cs


- 매크로를 이용한 함수의 인라인화는 전처리기에 의해서 처리, 키워드 inline을 이용한 함수의 인라인화는 컴파일러에 의해서 처리된다.

- 따라서 컴파일러는 함수의 인라인화가 성능에 해가 된다고 판단할 경우, 키워드를 무시하기도 하고 필요한 경우 일부 함수를 임의로 인라인 처리하기도 한다.

- 템플릿을 이용하면 자료형에 의존적이지 않은 함수를 만들 수 있다.


01-5 이름공간(namespace)에 대한 소개

이름충돌을 막기 위해 namespace를 만들고 함수나 변수를 선언하여 사용한다.
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>
 
// BestComImpl이라는 namespace 안에 함수 SimpleFunc를 정의
namespace BestComImpl
{
    void SimpleFunc()
    {
        std::cout << "BestCom이 정의한 함수" << std::endl;
    }
}
 
// ProgComImpl이라는 namespace 안에 함수 SimpleFunc를 정의
namespace ProgComImpl
{
    void SimpleFunc()
    {
        std::cout << "ProgCom이 정의한 함수" << std::endl;
    }
}
 
// ::을 가리켜 범위지정 연산자(scope resolution operator라 한다.
int main()
{
    BestComImpl::SimpleFunc();    
    ProgComImpl::SimpleFunc();    
    return 0;
}
cs


연산자 :: 을 가리켜 '범위지정 연산자'라 한다. namespace를 지정할 때 사용한다.

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
#include <iostream>
 
// BestComImpl이라는 namespace 안에 함수 SimpleFunc를 선언
namespace BestComImpl
{
    void SimpleFunc();
}
 
// ProgComImpl이라는 namespace 안에 함수 SimpleFunc를 선언
namespace ProgComImpl
{
    void SimpleFunc();
}
 
// ::을 가리켜 범위지정 연산자(scope resolution operator라 한다.
int main()
{
    BestComImpl::SimpleFunc();
    ProgComImpl::SimpleFunc();
    return 0;
}
 
// BestComImpl namespace에 선언된 함수 SimpleFunc를 정의
void BestComImpl::SimpleFunc()
{
    std::cout << "BestCom이 정의한 함수" << std::endl;
}
 
// ProgComImpl namespace에 선언된 함수 SimpleFunc를 정의
void ProgComImpl::SimpleFunc()
{
    std::cout << "ProgCom이 정의한 함수" << std::endl;
}
cs


namespace 기반에서 함수의 선언과 정의를 구분한다.


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
#include <iostream>
 
// BestComImpl이라는 namespace 안에 함수 SimpleFunc를 선언
namespace BestComImpl
{
    void SimpleFunc();
}
 
namespace BestComImpl
{
    void PrettyFunc();
}
 
// ProgComImpl이라는 namespace 안에 함수 SimpleFunc를 선언
namespace ProgComImpl
{
    void SimpleFunc();
}
 
// ::을 가리켜 범위지정 연산자(scope resolution operator라 한다.
int main()
{
    BestComImpl::SimpleFunc();
    return 0;
}
 
// BestComImpl namespace에 선언된 함수 SimpleFunc를 정의
void BestComImpl::SimpleFunc()
{
    std::cout << "BestCom이 정의한 함수" << std::endl;
    PrettyFunc();                // 동일 namespace
    ProgComImpl::SimpleFunc();    // 다른 namespace
}
 
// BestComImpl namespace에 선언된 함수 PrettyFunc를 정의
void BestComImpl::PrettyFunc()
{
    std::cout << "So Pretty!!" << std::endl;
}
 
// ProgComImpl namespace에 선언된 함수 SimpleFunc를 정의
void ProgComImpl::SimpleFunc()
{
    std::cout << "ProgCom이 정의한 함수" << std::endl;
}
cs


같은 namespace에 정의된 함수를 호출할 때에는 namespace를 명시할 필요가 없다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
 
namespace Hybrid
{
    void HybFunc()
    {
        std::cout << "So simple function!" << std::endl;
        std::cout << "In namespace Hybrid!" << std::endl;
    }
}
 
int main()
{
    using Hybrid::HybFunc;    // HybFunc 를 Hybrid namespace에서 찾으라는 일종의 선언
    HybFunc();
    return 0;
}
cs


using 키워드를 이용하여 HybFunc 함수를 호출할 때 namespace 범위 지정 없이 그냥 호출 할 수 있다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
 
using std::cin;
using std::cout;
using std::endl;
 
int main()
{
    int num = 20;
 
    cout << "Hello World!!" << endl;
    cout << "Hello " << "World!" << endl;
    cout << num << ' ' << 'A';
    cout << ' ' << 3.14 << endl;
    return 0;
}
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
 
using namespace std;
 
int main()
{
    int num = 20;
 
    cout << "Hello World!!" << endl;
    cout << "Hello " << "World!" << endl;
    cout << num << ' ' << 'A';
    cout << ' ' << 3.14 << endl;
    return 0;
}
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
#include <iostream>
using namespace std;
 
namespace AAA
{
    namespace BBB
    {
        namespace CCC
        {
            int num1;
            int num2;
        }
    }
}
 
int val = 100; // 전역변수
 
void SimpleFunc()
{
    int val = 20;    // 지역변수
    val += 3;        // 지역변수 val의 값 3 증가
    ::val += 7;        // 전역변수 val의 값 7 증가
    cout << val << endl;
    cout << ::val << endl;
}
 
int main()
{
    AAA::BBB::CCC::num1 = 20;
    AAA::BBB::CCC::num2 = 30;
 
    namespace ABC = AAA::BBB::CCC;
 
    cout << ABC::num1 << endl;
    cout << ABC::num2 << endl;
    SimpleFunc();
    return 0;
}
cs




저작자표시

+ Recent posts

티스토리툴바