C++에선 생성자 내부에서 대입을 통해 멤버를 정의하는 방법보단 멤버 이니셜라이저라는 특수한 문법으로 정의를 해주는 것을 권장한다. 성능면에서 전자보단 후자가 상대적인 이득을 본다는 것인데, 다른 블로그를 찾아봐도 "어느정도 " 차이가 나는지는 없어 짤막하게 테스트 해보려고 한다.

코드

#include <iostream>
#include <thread>
#include <time.h>

using namespace std;

class MyClass
{
public:
    MyClass() = delete;
    MyClass(int number)//이니셜라이저를 사용하지 않고, 대입을 통해 초기화
    {
        m_number1 = number;
        m_number2 = number;
        m_number3 = number;
        m_number4 = number;
    }
private:
    int m_number1;
    int m_number2;
    int m_number3;
    int m_number4;
};


class MyClass2
{
public:
    MyClass2() = delete;
    MyClass2(int number) ://이니셜라이저를 통해 초기화
        m_number1(number),
        m_number2(number),
        m_number3(number),
        m_number4(number)

    {

    }
private:
    int m_number1;
    int m_number2;
    int m_number3;
    int m_number4;

};


int main()
{
    bool ThreadDone1 = false;
    bool ThreadDone2 = false;

    thread Thread1([&ThreadDone1]()
    {
        clock_t start = clock();

        for (int i = 0; i < INT_MAX; i++)
        {
            MyClass a(5);
        }

        clock_t end = clock();

    std::cout << "Thread1 done Time : " << double(end - start) / CLOCKS_PER_SEC << "\n";
    ThreadDone1 = true;
    });
    Thread1.detach();


    thread Thread2([&ThreadDone2]()
    {
        clock_t start = clock();

        for (int i = 0; i < INT_MAX; i++)
        {
            MyClass2 a(5);
        }
        clock_t end = clock();
    std::cout << "Thread2 done Time : " << double(end - start) / CLOCKS_PER_SEC << "\n";

    ThreadDone2 = true;
    });
    Thread2.detach();

    while (ThreadDone1 != true || ThreadDone2 != true)
    {

    }

}

스레드 1번은 단순 대입 초기화, 스레드2번은 멤버 이니셜라이저를 이용한 초기화를 해주는 클래스를 반복 생성한다.

테스트 결과

테스트 1번

테스트 2번

테스트 3번

대략 6~9%정도의 성능 차이가 발생한다.

결론

C++의 말대로, 정의해주는 위치만 변경되었을 뿐인데 명확한 성능 차이를 보인다. 습관을 들여서라도 멤버 이니셜라이저를 자주 사용해야겠다는 생각이 들었다.

백준 온라인 저지에서 나온 문제입니다.

보물

문제 바로가기

구현 방식

stl sort를 사용하여 입력받은 수를 정렬하는 방식으로 구현했습니다.

코드

/*

https://www.acmicpc.net/problem/1026

*/

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;


int main()
{
    int    vecSize;
    int inputNumber;
    int total = 0;

    vector<int>    vecNumberA;
    vector<int>    vecNumberB;

    cin >> vecSize;

    vecNumberA.reserve(vecSize);
    vecNumberB.reserve(vecSize);

    for (int i = 0; i < vecSize; i++)
    {
        cin >> inputNumber;
        vecNumberA.push_back(inputNumber);
    }
    for (int i = 0; i < vecSize; i++)
    {
        cin >> inputNumber;
        vecNumberB.push_back(inputNumber);
    }

    sort(vecNumberA.begin(), vecNumberA.end(),greater<int>());
    sort(vecNumberB.begin(), vecNumberB.end(), less<int>());

    for (int i = 0; i < vecSize; i++)
    {
        total += vecNumberA[i] * vecNumberB[i];
    }

    cout << total << endl;

    return 0;
}

코드 해설

들어온 값들을 B는 내림차순으로, A는 오름차순으로 정렬해야 가장 적은 값이 나오는 문제입니다. 정렬을 간편하게 하기 위해서 sort함수를 사용하여 문제를 해결했습니다.

기타줄

문제 바로가기

해결 방식

그때그때 최적의 값을 고르는 그리디 알고리즘이라, 별다른 방법 없이 구현했습니다.

구현 코드

/*
https://www.acmicpc.net/problem/1049
*/


#include <algorithm>
#include <stdio.h>
#include <iostream>
#include <algorithm>

using namespace std;



int main()
{
    int guitarString = 0;
    int brandCount = 0;
    int result = 0;


    int cheapestPackage = 99999;
    int cheapestSingle = 99999;

    int inputPackageCost;
    int inputSingleCost;


    cin >> guitarString >> brandCount;

    for (int i = 0; i < brandCount; i++)
    {
        cin >> inputPackageCost >> inputSingleCost;

        cheapestPackage = min(inputPackageCost, cheapestPackage);
        cheapestSingle = min(inputSingleCost, cheapestSingle);
    }

    if (cheapestPackage > cheapestSingle * 6)//단품가가 세트가보다 쌀 경우 바로 구매
    {
        result = cheapestSingle * guitarString;
        cout << result;
        return 0;
    }
    /*
    여기까지 왔으면 패키지가 단품보다 싸나,
    추가적으로 낱개로 구매할 상황이 나온 경우.
    */
    while (guitarString > 0)
    {
        if (guitarString >= 6)
        {
            result += cheapestPackage;
            guitarString -= 6;
        }
        else if (cheapestPackage < cheapestSingle * guitarString)//줄의 개수가 6개 이하인데
        {
            result += cheapestPackage;
            guitarString = 0;
        }
        else
        {
            result += cheapestSingle;
            guitarString--;
        }
    }
    cout << result;

    return 0;
}

결과

랭크업 굿

해당 문제는 백준 온라인 저지에서 나온 문제입니다

피보나치 함수

문제 바로가기

해결방식

제한시간 0.25초 내에 입력된 값을 처리해야하는 문제입니다. 다이나믹 프로그래밍 알고리즘을 활용하고, 값을 배열에 등록하여 재귀를 타고 수열을 쪼개는 횟수를 줄여야 하는 것이 중요한 문제였습니다.

코드

/*
https://www.acmicpc.net/problem/1003
*/

/*

기존 피보나치는 Top-Down 방식으로 작업해도 괜찮았지만,
여기 피보나치에서 요구하는 것은 짧은(중요) 시간 내에 정해진 값에 도달하는 것입니다.
그러므로 천천히 값을 쌓아서 올라가는 방식인 Bottom-UP 방식으로 진행됩니다.
오히려 코드의 구현은 사람이 피보나치 수열을 만들때의 그것과 유사합니다.

배열에 값을 저장하고, 다음 값이 올때 이를 출력하는 것입니다.
*/


#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

pair<int, int>    CalledFibonacci[40];

pair<int, int> fibonacci(int n, int goal)[0]
{
    pair<int, int>    currentPair;

    if (n == 0)
        currentPair = { 1,0 };

    if (n == 1)
        currentPair = { 0,1 };

    if (n > 1)
    {    
        currentPair.first = CalledFibonacci[n - 1].first + CalledFibonacci[n - 2].first;
        currentPair.second = CalledFibonacci[n - 1].second + CalledFibonacci[n - 2].second;
    }
    CalledFibonacci[n] = currentPair;
    if (n == goal)
    {
        return currentPair;
    }
    return fibonacci(++n, goal);
}

int main()
{
    int        inputCount = 0;
    int        inputNumber = 0;
    vector<int> vecTestNumber;

    cin >> inputCount;

    for (int i = 0; i < inputCount; i++)
    {
        cin >> inputNumber;
        vecTestNumber.push_back(inputNumber);
    }

    for (int i = 0; i < inputCount; i++)
    {
        pair<int, int> result;

        if (vecTestNumber[i] == 1)
            result = fibonacci(1, vecTestNumber[i]);
        else
            result = fibonacci(0, vecTestNumber[i]);

        cout << result.first << " " << result.second << endl;

    }
    return 0;
}

코드 해설

pair 구조체를 활용하여 기존 피보나치 수열의 방식과 유사하게 작업했습니다.

해당 문제는 백준 온라인 저지에서 나온 문제입니다

단어 정렬

문제 바로가기

해결 방식

자동 정렬과 조건을 수행하기 위해 STL 컨테이너 중 우선순위 큐를 사용하여 문제를 해결했습니다.

코드

// Baekjoon.cpp : 이 파일에는 'main' 함수가 포함됩니다. 거기서 프로그램 실행이 시작되고 종료됩니다.
//


/*
https://www.acmicpc.net/problem/1181
*/


#include <iostream>
#include <algorithm>
#include <queue>
#include <list>
#include <string.h>
using namespace std;

struct cmp [0]
{
    bool operator()(string dest, string sour)
    {
        if (dest.size() == sour.size())
        {
            int compare = strcmp(dest.c_str(), sour.c_str());

            return compare > 0;
        }
        else
        {
            return dest.size() > sour.size();
        }
    }
};


int main()
{
    priority_queue<string, vector<string>, cmp> wordQueue;
    string    popedWord;

    int wordCount = 0;
    string word;

    cin >> wordCount;

    for (int i = 0; i < wordCount; i++)
    {
        cin >> word;
        wordQueue.push(word);
    }

    while (!wordQueue.empty())
    {
        if (!popedWord.empty() &&
            strcmp(wordQueue.top().c_str(), popedWord.c_str()) == 0)
        {
            wordQueue.pop();
        }
        else
        {
            cout << wordQueue.top() << endl;
            popedWord = wordQueue.top();
            wordQueue.pop();
        }
    }
}

코드 해설

0번 구문은 함수호출 연산자를 활용하여 두 원소를 비교하여 매번 처리를 진행했습니다. string이 비용이 많이 잡아먹긴 하나, 성능이 강력하고 문제에서 제시한 메모리 비용을 넘지 않을 것이라 예상해 사용했습니다.

중복되는 값을 처리하기 위해, 가장 최근에 pop된 문자열을 기억하고 있다가, 중복되는 값이 나오면 출력을 건너뛰게 처리했습니다.

영화감독 숌

문제 바로가기

해결 방식

브루트 포스 알고리즘, 완전 탐색 알고리즘이라 부르는 방식으로 모든 경우의 수를 가정하여 작업했습니다.

코드

// Baekjoon.cpp : 이 파일에는 'main' 함수가 포함됩니다. 거기서 프로그램 실행이 시작되고 종료됩니다.
//


/*
https://www.acmicpc.net/problem/1181
*/

#include <iostream>
#include <stdio.h>
#include <string>
using namespace std;

bool    inNumber666(int number)[0]
{
    string numberStr;

    numberStr = to_string(number);

    int        count = 0;
    for (int i = 0; i < numberStr.size() - 2; i++)
    {
        if (numberStr[i] != '6')[1]
            continue;
        count = 0;
        for (int j = i; j < i + 3; j++)
        {
            if (numberStr[j] == '6')
                count++;
            else[2]
                break;
        }
        if (count >= 3)
        {
            return true;
        }
    }
    return false;
}

int main()
{
    int movieNumber = 666;

    int index = 0;
    int findNumber = 0;

    cin >> findNumber;

    while (1)
    {
        if (inNumber666(movieNumber))
        {
            index++;
            if (index == findNumber)
                break;
        }
        movieNumber++;
    }

    cout << movieNumber;

    return 0;
}

코드 해설

모든 경우의 수를 검사하는 완전탐색 문제이므로 0번 구문의 조건에 맞을때까지 반복문을 돌며 정답을 찾습니다.

1번과 2번 구문은 해당 값이 "완전히" 조건에서 벗어난 케이스를 예외처리 하여 검사횟수를 줄였습니다.

오늘 점수

계속 ㄱㄱ

여담

2번 영화감독 숌의 경우, 처음에는 완전탐색 문제인지 모르고 효율적인 방식을 찾아보겠다고 이리저리 고집하다가, 결국 반복문을 돌리는 것으로 끝났습니다. 문제를 제대로 판별하는 능력을 기르는 것이 중요하겠네요.

해당 문제는 백준 온라인 저지에서 나온 문제입니다.

펠린드롬 수

문제 바로가기

해결 방식

탐욕 알고리즘으로, 검사할 때마다 앞뒤 두 숫자를 잘라서 비교하는 방식으로 문제를 해결했습니다.

해결 방식을 고른 이유

그때그때 가장 최적의 값을 고르는 그리디 알고리즘 문제였기에, 별다른 알고리즘 없이 해결하였습니다.

코드

// Baekjoon.cpp : 이 파일에는 'main' 함수가 포함됩니다. 거기서 프로그램 실행이 시작되고 종료됩니다.
//


/*
https://www.acmicpc.net/problem/1259
*/


#include <iostream>

using namespace std;


int main()
{
    int numberList[1000];

    int inputNumber = 0;
    bool bIsCompare;
    while (1)
    {
        cin >> numberList[inputNumber];

        if (numberList[inputNumber] == 0)
            break;
        inputNumber++;
    }
    for (int i = 0; i < inputNumber; i++)
    {
        if (numberList[i] < 10)//예외조건
        {
            cout << "yes" << endl;
            continue;
        }
        bIsCompare = true;


        //정의[1]
        int frontDigit = 1;
        while (frontDigit * 10 < numberList[i])
        {
            frontDigit *= 10;
        }
        //비교[2]
        while (numberList[i] > 0)
        {

            int numberHead = numberList[i] / frontDigit;
            int numberTail = numberList[i] % 10;

            if (numberHead != numberTail)
            {
                bIsCompare = false;
                break;
            }
            numberList[i] %= frontDigit;
            numberList[i] /= 10;

            frontDigit /= 100;

            if (numberList[i] < 10)
                break;
        }
        //출력[3]
        if (bIsCompare)
        {
            cout << "yes" << endl;
        }
        else
         {
            cout << "no" << endl;
        }
    }
}

코드 해설

[1]번 구문에서 통해 앞에서 자를 숫자단위를 구했습니다. [2]번 구문에서 구한 값을 통해 해당배열 숫자의 앞자리, 뒷자리 숫자를 구해 값이 같은지 검사했습니다.

체스판 다시 칠하기

문제 바로가기

해결 방식

검은색으로 시작하는 체스판과 하얀색으로 시작하는 두개의 체스판을 만들어, 입력받은 체스판과 매번 비교해 최소값을 구했습니다.

해결방식을 고른 이유

모든 경우의 수를 비교해야하기에, 완전탐색을 활용하여 구현했습니다.

코드

// Baekjoon.cpp : 이 파일에는 'main' 함수가 포함됩니다. 거기서 프로그램 실행이 시작되고 종료됩니다.
//


/*
https://www.acmicpc.net/problem/1018
*/


#include <iostream>
#include <algorithm>
using namespace std;

//[0]검사용 체스판을 만드는 함수
void MakeBoardCase(char*** board, int width, int height, bool startColor)
{
    *board = new char* [height];
    bool color;
    for (int i = 0; i < height; i++)
    {
        (*board)[i] = new char[width];
        (*board)[i][width] = '\0';

        color = startColor;
        for (int j = 0; j < width; j++)
        {
            if (color)
            {
                (*board)[i][j] = 'B';
            }
            else
            {
                (*board)[i][j] = 'W';
            }
            color = !color;
        }
        startColor = !startColor;
    }
}

//[1]검사용 체스과 체스판을 검사해, 다시 칠해야 하는 부분을 리턴하는 함수

int SolvedPainted(char** board, char** checkBoard, int startX, int endX, int startY, int endY)
{
    int    paintedCount = 0;

    int checkI = 0;
    int checkJ = 0;


    for (int i = startY; i < endY; i++)
    {
        checkJ = 0;
        for (int j = startX; j < endX; j++)
        {
            if (board[i][j] != checkBoard[checkI][checkJ])
            {
                paintedCount++;
            }
            checkJ++;
        }
        checkI++;
    }
    return paintedCount;
}


int main()
{
    int width =        0;
    int height =    0;
    int minPaintCount = 99999;


    char** board;
    char** CheckCase1;
    char** CheckCase2;

    MakeBoardCase(&CheckCase1, 8, 8, 1);
    MakeBoardCase(&CheckCase2, 8, 8, 0);

    cin >> height >> width;
    board = new char* [height];

    for (int i = 0; i < height; i++)
    {
        board[i] = new char[width];

        cin >> board[i];
    }

    for (int i = 0; i < height; i++)
    {
        if (i + 8 > height)
            continue;
        for (int j = 0; j < width; j++)
        {
            if (j + 8 > width)
                continue;

            int paintCount1 = SolvedPainted(board, CheckCase1, j, j + 8, i, i + 8);
            int paintCount2 = SolvedPainted(board, CheckCase2, j, j + 8, i, i + 8);

            minPaintCount = min(minPaintCount, paintCount1);
            minPaintCount = min(minPaintCount, paintCount2);
        }
    }
    cout << minPaintCount;

    /*
    cout << endl << "case1" << endl;
    for (int i = 0; i < 8; i++)
    {
        cout << CheckCase1[i];
        cout << endl;
    }

    cout << endl << "case2" << endl;
    for (int i = 0; i < 8; i++)
    {
        cout << CheckCase2[i];
        cout << endl;
    }
    */

}

코드 해설

검사용 체스판을 만들기 위해 [0]번 함수를 작성했습니다. 반복문을 돌며 입력받은 체스판과 , 두 개의 검사용 체스판과 매번 비교해 최소값을 구해 이를 출력하였습니다

백준 랭크

차근차근 올립시다

여담

제가 글을 대충읽는 성격이라그런지, 체스판 칠하기 문제를 잘못 이해해서 시간이 한참 걸렸네요. 문제를 정확하게 파악하는 능력을 길러야할 것 같습니다.

해당 글은 fundamental C++을 참고하여 작성되었습니다.

이번 글에서는 클래스의 메모리가 어떻게 배치되는지와 메모리의 오프셋에 대해 알아보겠습니다.

1.멤버 변수와 정적 멤버 변수의 차이.

간단한 코드를 하나 작성하겠습니다. myClass타입의 객체 temp를 생성했습니다. 선언된 temp의 메모리 구조는 대략 이렇습니다. 중요한 것은 정적 멤버 변수인 m_SInt와 멤버 함수인 m_func는 메모리 영역에 포함되어 있지 않다는 점입니다. 실제로 메모리 영역에 포함되어 있는 것은 일반 멤버 변수들뿐이죠.

멤버 변수는 객체의 상태나 정보를 나타내기 위해서 존재합니다. 그에 비해서 정적 멤버 변수는 객체가 아닌 클래스의 상태와 정보를 나타냅니다. 따라서 멤버 변수는 각 객체마다 존재하지만, 정적 멤버 변수는 하나만 존재할 수 있습니다. 이는 전역변수와 같이 어떤 객체에서든 정적 멤버 변수에 접근할 수 있기에, m_SInt는 전역변수가 저장되는 전역 메모리 데이터 영역에 4바이트만큼 존재하며, myClass에 모든 객체가 이를 공유할 수 있습니다.

그렇다면 실제 메모리 영역에서 멤버 변수들은 어떻게 저장될까요? 위에 코드는 0을 myClass* 타입으로 캐스팅하여 시작 주소를 0으로 맞춰놓은 뒤, 각 멤버 변수의 시작 위치를 출력시키는 코드입니다. 참고로 멤버 변수의 주소는 클래스에서 선언한 순서대로 쌓이게 됩니다. 한번 코드를 실행시켜봅시다. 뭔가 이상하죠? byte의 값으로 봤을 때 이상적인 출력결과는 분명 [1,4,5]인데 말이죠. 여기에는 한가지 비밀이 숨어있습니다. 바로 오프셋이라는 친구가말이에요.

2.멤버 변수의 오프셋

오프셋의 정의부터 먼저 짚고 넘어갑시다. 간단하게 풀어설명하자면, "두개의 값 사이의 간격"정도로 생각하면 되겠습니다.

컴파일러는 생각보다 하는일이 꽤 많습니다. 소스코드를 읽어 어셈블리언어로 변환하는게 주된 일이지만, 코드의 성능을 높이기 위해 코드를 직접 최적화하기도 합니다.(예를 들면 암시적 형변환이 있겠네요.) 클래스 객체의 메모리 배치도 컴파일러가 하는 일 중에 하나입니다.

컴파일러는 /ZpN 옵션을 가지고 객체의 메모리 오프셋을 설정합니다. 비주얼 스튜디오에서는 프로젝트속성에서 확인 할 수 있습니다. 컴파일러는 멤버 변수를 메모리에 위치시킬 때, 변수 타입의 크기와 N(기본값은 8입니다)중 작은 쪽의 최소 배수가 되도록 조정을 하게 됩니다. 그렇기에 m_char는 첫 멤버 변수이므로 0에 위치하게 되며, m_int는 (4,8)중에서 작은 쪽인 4의 배수인 4의 오프셋을 가지게됩니다. 이후 double는 1 + 3 + 4 = 8이므로 자연스럽게 오프셋 8에 위치합니다. 감이 잘 안잡히죠? 예시로 몇개 더 해봅시다.

Zp8 일 경우, 클래스 메모리의 오프셋이 어떻게 출력될까요?

1.[0, 1, 9] 2.[0, 8, 9] 3.[0, 8, 16]

1.[0, 4, 8] 2.[0, 8, 12] 3.[0, 4, 12]

1.[0, 8, 12] 2.[0, 8, 9] 3.[0, 8, 16]

기본적인 메모리 배치만 알면 되겠고, Zp1, Zp2 등등... 많긴 한데 그것들까지 다 할 필요성까지는 느끼지 못했네요. 오늘은 여기까지 하고 정답은 댓글로 남겨놓겠습니다.

그럼 바윙~

이 글은 fundamental c++의 내용을 참고하여 작성되었습니다.

1.C의 구조체, C++의 구조체.

C를 공부하신 분들은 구조체에 대해 아실겁니다. 명확하게 정의를 하자면 "여러 타입의 자료형을 한 곳에 모아놓은 확장 자료형"이죠. 말 그대로 확장된 자료형이기에 함수를 추가한다거나 하는 행동은 C에서는 불가능합니다. 그럼 C++에서는 과연 어떨까요?

#include <stdio.h>

typedef struct myStruct
{
    int        a;
    int        b;
    void    printMyName()
    {
        printf("my name is 뉴트리아!\n");
    }
}            myStruct;

int    main()
{
    myStruct    myStruct;
    myStruct.printMyName();
    return 0;
}

아래 코드를 각각 c, c++환경에서 컴파일 해보겠습니다. 예상했던대로 c에서는 printMyName이란 멤버를 가질 수 없다고 나오죠. c++에서 동일한 코드가 정상적으로 나오는 것을 볼 수 있습니다. 이는 C++ 컴파일러를 사용하면서 구조체의 기능이 클래스처럼 확장되었다고 보는것이 맞다고 할 수 있습니다.

이렇게 보면 구조체와 클래스는 차이점이 없다고 볼 수 있지만, 접근 지정자 부분에서 꽤나 큰 차이를 보입니다.

2. 클래스와 구조체의 기본 접근 지정자

둘의 차이 중 하나는 기본적으로 주어지는 접근 지정자가 다르다는 것입니다.

구조체의 기본 접근 지정자는 public, 클래스의 기본 접근 지정하는 private로 서로 다른 것을 알 수 있습니다.

typedef struct myStruct
{
    int        a;
    int        b;
    void    printMyName()
    {
        printf("구조체 : my name is 뉴트리아!\n");
    }
}myStruct;

class    myClass
{
    int        a;
    int        b;
    void    printMyName()
    {
        printf("클래스 : my name is 뉴트리아!\n");
    }
};

여기 동일한 기능을 하는 구조체와 클래스가 있습니다. 멤버 모두 동일하며 접근 지정자를 따로 선언하지도 않았습니다. 먼저 구조체부터 다시 실행시켜보겠습니다. 정상적으로 실행됩니다. 그러면 클래스도 동일하게 실행시켜보겠습니다. 호출하려는 해당 함수가 private라 접근이 불가능하다고 컴파일 단계에서 오류를 띄워줍니다. 당연하게도 접근 지정자를 pulbic으로 해주면 문제는 해결되지요. 그렇다면 왜 구조체와 클래스의 기본 접근 지정자가 다른 것일까요?

C언어에서는 예전부터 아~주 많은 프로그램에서 구조체가 사용되고 있었으며, 애초에 그 당시엔 구조체에 접근 지정자라는 개념 자체가 없었습니다. 만약 구조체의 기본 접근 지정자가 private라면, 그동안 만들어진 모든 소스코드들 모드 컴파일이 되지 않을 것입니다. 또한 접근 지정자는 객체지향 개념에서 클래스의 캡슐화(또는 정보은닉화)개념을 구현하기 위해 도입된 것이므로, 하위 호환성 고려는 물론 외부의 접근을 자유롭게 허용하는 구조체는 당연히 public으로 지정될 수 밖에 없는 것이지요.

하지만 클래스는 캡슐화를 기본으로 하면서 외부에 공개할 것을 특별히 public을 지정하도록 설계가 되어있기에 기본 접근 지정자가 private인 것입니다.

저는 코드를 작성할 때 작은 범위의 클래스가 필요할때는 구조체를 주로 사용하고, 나머지는 클래스로 작성하는 스타일을 가지고 있습니다. 예를 들어 RPG를 만든다면, 몬스터의 클래스 안에 몬스터의 좌표를 저장하는 pt라는 구조체를 사용하는 형태로 코드를 작성합니다.

요약. 1.구조체는 기본 접근 지정자가public인 이유는 호환성 때문. 2.클래스는 기본 접근 지정자가 private인 이유는 객체지향 설계 때문. 3.상황에 맞게 잘 쓰자.

해당 문제는 백준온라인 저지에서 나온 문제입니다.

해결 방식

백트래킹 알고리즘을 활용하여 작성하였습니다 백트래킹 자료 1 백트래킹 자료 2 두가지 블로그를 참고하였습니다.

해결 방식을 고른 이유

인접한 모든 노드를 집어넣고 탐색을 시작하는 BFS알고리즘의 방식은 문제의 조건때문에 선택하기가 힘들다고 판단하였습니다. 따라서 DFS방식을 활용한 백트래킹 알고리즘을 선택하였습니다.

코드

#include <iostream>
#include <vector>
#include <string>

using namespace std;

char map[20][20];
int dir[4][2] = { {1,0},{-1,0},{0,1},{0,-1} };//이동할 방향

vector<char> road;
int cnt =  0;
int R, C;//R이 세로 C가 가로
bool    isValid(char num)//중복되지 않는 문자인지 검사
{
    if (road.empty())
        return true;
    for (int i = 0; i < road.size(); i++)
    {
        if (road[i] == num)
            return false;
    }
    return true;
}

void solution(int x, int y)
{
    road.push_back(map[y][x]);
    for (int i = 0; i < 4; i++)
    {
        if (x + dir[i][0] >= C || y + dir[i][1] >= R)
            continue;
        if (x + dir[i][0] < 0 || y + dir[i][1] < 0)
            continue;
        if (!isValid(map[y + dir[i][1]][x + dir[i][0]]))
            continue;
        solution(x + dir[i][0], y + dir[i][1]);
    }
    if (!road.empty())//[1]
    {
        if ((int)road.size() > cnt)
            cnt = (int)road.size();
        road.pop_back();
    }
}

int main()
{
    string str;
    cin >> R >> C;
    for (int i = 0; i < R; i++)
    {
        cin >> str;
        for (int j = 0; j < C; j++)
        {
            map[i][j] = str[j];
        }
    }
    solution(0, 0);
    cout << cnt << endl;
}

코드 해설

코드의 핵심 부분은 solution 함수입니다. 반복문을 돌며 상하좌우 조건에 맞는 경로를 재귀로 호출하여 이동합니다. 탐색이 끝난 경로는 리스트에서 제외해야 하기 때문에 [1]의 제어문을 두어 현재 경로와 최장 경로를 비교하고(현재 경로가 크다면 cnt를 이로 바꿔줍니다.) pop_back을 통해 마지막으로 이동한 경로를 지워 다음 탐색을 진행합니다.

해당 문제는 백준온라인 저지에서 나온 문제입니다.

해결 방식

너비 우선 탐색 알고리즘(BFS)을 베이스로 작성하였습니다.

해결 방식을 고른 이유

완전탐색을 요구하는 문제로 깊이우선탐색으로는 정확한 해를 찾을 수 없다고 생각하여, 너비우선탐색 알고리즘을 선택하여 작성하였습니다.

저는 깊이우선방식과 너비우선방식 중에서 선택을 할때, 문제의 키워드를 보고 고릅니다. 대략적으로 최적의,가장 빠른 같은 키워드가 나올때는 너비우선탐색으로 진행하고, 그렇지 않은 경우 깊이우선탐색으로 코드를 짜는 편입니다.

코드

#include <iostream>
#include <queue>

using namespace std;

queue<int> ql;
queue<int> qc;
int visted[100001];
void push_q(int range, int cnt)
{
    ql.push(range);
    qc.push(cnt);
}

void    pop_q(int* range, int* cnt)
{
    *range = ql.front();
    ql.pop();
    *cnt = qc.front();
    qc.pop();
}

int main()
{
    int N, K;
    int    range, c;
    range = 0;
    c = 0;
    cin >> N >> K;
    push_q(N, 0);
    visted[N] = 1;
    while (qc.size() != 0 && ql.size() != 0)
    {
        pop_q(&range, &c);
        if (range == K)
        {
            cout << c << endl;
            break;
        }
        if (range + 1 <= 100000 && visted[range + 1] == 0)
        {
            push_q(range + 1, c + 1);
            visted[range + 1] = 1;
        }
        if (range * 2 <= 100000 && visted[range * 2] == 0)
        {
            push_q(range * 2, c + 1);
            visted[range * 2] = 1;
        }
        if (range - 1 <= 100000 && visted[range - 1] == 0 && range - 1 >= 0)
        {
            push_q(range - 1, c + 1);
            visted[range - 1] = 1;
        }
    }
}

코드 해설

주변에 존재하는 모든 노드를 넣고 탐색을 진행하는 너비 우선 탐색은 큐를 사용하여 작성하는것이 편합니다. visted 변수는 같은 수를 계산하지 않기 위해서 넣은 것입니다. 예를 들어서 N =1, K = 1000의 경우, 맨 처음 while문에서 2,2,0의 값이 들어갑니다. 다음 반복에서 2를 꺼내어 3,4,1을 넣을 것이고, 그 다음 반복문에서도 2를 꺼내 3,4,1을 넣습니다. 이처럼 같은 값이 반복되서 들어가는 것을 막기 위해 visted변수를 놓아 중복을 막는것입니다. 계속 push,pop을 반복하며 pop한 값이 K값과 같다면 c를 출력하고 반복문을 끝냅니다.

해당 문제는 백준온라인 저지에서 나온 문제입니다.

해결 방식

깊이 우선 탐색 알고리즘(DFS)을 베이스로 작성하였습니다.

해결 방식을 고른 이유

너비 우선 탐색 알고리즘은 최적의 해를 찾기 유용하지만, 그만큼 비용이 많이들어가며, 형제인 모든 노드를 탐색하기때문에 상대적으로 시간이 많이걸립니다. 깊이 우선 탐색은 상대적으로 구현이 간단하고, 목표 노드가 깊은 곳에 있을 경우 빠른 속도로 해를 구할 수 있습니다. 단점으로는 주변 모든 노드를 탐색하는것이 아니라 자신이 선택한 뎁스에서만 탐색을 진행하기 때문에, 얻어진 해가 최적의 결과가 아닐 수가 있습니다.

해당 문제는 깊이우선탐색으로도 최적의 해를 구할 수 있으며, 구현이 간단하기에 이를 선택하였습니다.

코드

#include <iostream>
#include <vector>

using namespace std;

int map[50][50] = { 0, };
int mask[50][50] = { 0, };
int    dir[4][2] = { {1,0},{-1,0},{0,1},{0,-1} };//이동할 방향
int M, N, K;
void    clear_map(int width, int height)
{
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            map[i][j] = 0;
            mask[i][j] = 0;
        }
    }
}

void    solution(int x, int y)
{
    if (map[y][x] == 0)//배추가 존재한다면
        return;
    if (mask[y][x] == 0)//처음 지나가는 배추일 경우.
        mask[y][x] = 1;//다음번 탐색에서 제외
    for (int i = 0; i < 4; i++)
    {
        if ((x + dir[i][0] >= M || y + dir[i][1] >= N) || (x + dir[i][0] < 0 || y + dir[i][1] < 0))//이동할 경로가 맵의 범위를 벗어나는 경우
            continue;
        if (mask[y + dir[i][1]][x + dir[i][0]] == 1)//해당 경로에 배추가 있는지
            continue;
        mask[y + dir[i][1]][x + dir[i][0]] == 1;
        solution(x + dir[i][0], y + dir[i][1]);
    }
}
int main()
{
    int T;
    cin >> T;
    vector<int> answer;

    for (int t_case = 0; t_case < T; t_case++)
    {
        //init start
        int x, y;
        int cnt = 0;
        cin >> M >> N >> K;
        clear_map(M, N);

        for (int i = 0; i < K; i++)
        {
            cin >> x >> y;
            map[y][x] = 1;
        }
        //init end
        for (int y = 0; y < N; y++)
        {
            for (int x = 0; x < M; x++)
            {
                if (map[y][x] == 1 && mask[y][x] == 0)
                {
                    solution(x, y);
                    cnt++;
                }
            }
        }
        answer.push_back(cnt);
    }
    for (int i = 0; i < answer.size(); i++)
        cout << answer[i] << endl;
}

코드 해설

핵심적인 부분은 solution 부분입니다.

DFS 알고리즘을 활용하여, 재귀를 돌며 조건에 맞을 때까지 탐색을 진행합니다. map은 배추밭 농장을 의미하고, mask는 이미 탐색한 경로를 의미합니다. mask가 필요한 이유는 이미 지나온 노드를 한번 더 탐색하는 것을 방지하기 위한 것인데, 만약 지나온 곳을 적어놓지 않는다면, 0,0번째 배열에서 탐색을 진행하고, 0,1번째 배열에서 또다시 탐색을 진행할 것입니다. 이런 문제를 방지하기 위해 mask라는 이중배열을 선언하여 지나온 곳을 적어놓아 다음번 탐색에서 제외해놓는 겁니다.

해당 문제는 삼성 익스퍼트 아카데미에서 나온 파리퇴치 문제입니다.

해결 방식

브루트 포스 알고리즘을 바탕으로 코드를 작성하였습니다

해결 방식을 고른 이유

문제에서 제시하는 방식이 DP, BFS, DFS를 활용하지 않아도 충분히 풀 수 있다고 생각하였고, 위 알고리즘을 해결하여 작성하여도 수행속도가 크게 차이가 나지 않을것이라 판단하여 구현이 간단한 해결 방식을 골랐습니다.

코드

#include <iostream>
#include <stdlib.h>
using namespace std;

int        n;//배열의 크기
int        m;//파리채의 크기.
int**        list;
int        sol(int y, int x)
{
    int temp = 0;
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < m; j++)
        {
            temp += list[y + i][x + j];
        }
    }
    return temp;
}

int main()
{
    int        big = 0;
    int        temp = 0;

    //벡터 초기화.
    cin >> n >> m;
    list = (int**)malloc(sizeof(int*) * n);
    for (int i = 0; i < n; i++)
        list[i] = (int*)malloc(sizeof(int) * n);
    int range = (n + 1) - m;//파리채의 범위 내에서 반복문을 돌기 위해 범위 설정
    for (int i = 0; i < range; i++)
    {
        for (int j = 0; j < range; j++)
        {
            temp = sol(i, j);
            if (big < temp)
                big = temp;
        }
    }
    cout << big << endl;
}

코드 해설

파리채로 파리가 가장 많이 있는 곳을 후려쳐, 죽인 수를 출력하는게 문제에서 요구하는 것입니다. 즉, 특정한 수가 아닌 최대 개수를 구하는 것이 목적이기에, 파리채의 범위를 벗어나는 구간은 탐색하지 않아도 됩니다.(가로세로 5칸의 배열, 2*2크기의 파리채의 경우, 배열의 5번째 칸을 시작으로 파리채를 후려치는 상황은 생각하지 않아도 된다는겁니다.)

dfs,bfs를 활용하여 1을 제외한 노드를 탐색할 때마다 개수를 1개씩 누적하여 이를 출력하는 프로그램을 작성하는것이 문제의 요지이다. 미로찾기처럼 중간에 답이 있는것이 아닌, 모든 노드를 탐색해야하는 문제이다. 그렇기에 큐를 쓰는 bfs알고리즘보다는 dfs를 활용하여 간단하게 코드를 작성하였다.

#include <iostream>
#include <vector>

using namespace std;

vector<int> nodes[101];
int visited[101] = { 0, };
int cnt = 0;

void    dfs(int i)
{
    for (int j = 0; j < nodes[i].size(); j++)
    {
        if (visited[nodes[i][j]] == 0)
        {
            cnt++;
            visited[nodes[i][j]] = 1;
            dfs(nodes[i][j]);
        }
    }
    return;
}

int main()
{
    int node_cnt;
    int link_cnt;
    int node_i;
    int link;

    scanf("%d", &node_cnt);
    scanf("%d", &link_cnt);

    for (int i = 1; i <= link_cnt; i++)
    {

        scanf("%d %d", &node_i, &link);
        nodes[node_i].push_back(link);
        nodes[link].push_back(node_i);
    }
    visited[1] = 1;
    dfs(1);
    printf("%d", cnt);
}

1을 만났을 때, 상하좌우에 인접한 다른 1이 있는지를 계속 검사한다. 내가 원하는 선택지로부터 계속해서 파고들기때문에, 이는 dfs알고리즘을 활용하여 푸는것이 적절하다고 생각하였다.

visited배열이 필요한 이유 : 한번 이동한 경로를 체크해야 다음 번 반복문에서 같은 노드를 중첩하여 검사하지 않기 때문이다.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int map[25][25] = { 0, };
int visited[25][25] = { 0, };
int dir[4][2] = { {1,0},{-1,0},{0,1},{0,-1} };
int cnt = 0;

void dfs(int x, int y,int size)
{
    if (map[y][x] == 1)
    {
        cnt++;
        visited[y][x] = 1;
        for (int i = 0; i < 4; i++)
        {
            if (x + dir[i][0] >= size || y + dir[i][1] >= size ||
                x + dir[i][0] < 0 || y + dir[i][1] < 0)
                continue;
            if (visited[y + dir[i][1]][x + dir[i][0]] == 1)
                continue;
            if (map[y + dir[i][1]][x + dir[i][0]] == 0)
                continue;
            visited[y + dir[i][1]][x + dir[i][0]] = 1;
            dfs(x + dir[i][0], y + dir[i][1], size);
        }
        return;
    }
    return;
}
int main()
{
    int size;

    vector<int> cnts;
    scanf("%d", &size);
    for (int i = 0; i < size; i++)
    {
        for (int j = 0; j < size; j++)
            scanf("%1d", &map[i][j]);
    }
    for (int i = 0; i < size; i++)
    {
        for (int j = 0; j < size; j++)
        {
            cnt = 0;
            if (map[i][j] == 1 && visited[i][j] == 0)
            {
                visited[i][j] = 1;
                dfs(j, i, size);
                cnts.push_back(cnt);
                cnt = 0;
            }
        }
    }
    sort(cnts.begin(), cnts.end(), less<int>());
    printf("%d\n",cnts.size());
    for (int i = 0; i < cnts.size(); i++)
    {
        printf("%d\n", cnts[i]);
    }
}

read 파일은 매개변수 buf에 최대 size만큼의 값을 불러오고, 불러온 값은 int형으로 리턴한다. 이때, buf의 마지막에 \0이 붙는다는 보장이 없기에, 사용자가 알아서 붙여줘야함. 맵 파싱할때 이거 깜빡했다가 이틀정도 날려먹었음.

2.되도록 이미지를 생성해서 그려주기.

처음에는 pixel_put함수가 직관적이여서 편할 수 있으나, 가면 갈수록 프레임이 기하급수적으로 떨어지는걸 볼 수 있음. mlx_do_sync랑 mlx이미지를 활용해서 렌더링을 구현하자.

3.윈도우즈 환경에서 \n은 newline이랑 캐리지 리턴이 존재한다.

간단하게 얘기하면, 맥에서는 개행문자가 \n만 존재하지만, 윈도우즈에선 캐리지 리턴이라는 것이 추가적으로 존재한다.(자세한건 검색으로) 그래서 맵의 y값을 리드할때 한줄 더 읽어와서 버퍼 오버플로가 뜨는 경험이 있었음.

스택을 써도 되고, 큐를 써도 되고, 배열을 써도 되는 문제. 나는 머리속에서 가장 빨리 떠오른 방법으로 해결했다.

해결 방법

주식을 산 뒤, 기본적으로 1초는 보장된다. 그러니 time에 1값을 준뒤에 이중 for문으로 검사를 진행하면 된다.

해결 코드

#include <string>
#include <vector>

using namespace std;

vector<int> solution(vector<int> prices) {
    vector<int> answer;
    int i = 0;
    int j =0;
    int time = 0;
    while(i < prices.size() -1)
    {
        j = i + 1;
        time = 1;
        while(j < prices.size()-1)
        {
           if (prices[i] > prices[j])
               break;
           time++;
           j++;
        }
        answer.push_back(time);
        i++;
    }
    answer.push_back(0);
    return answer;
}

스택이나 큐로 진행해도 되는거지만, 기본적인 처리속도는 같기에.(큰 while문이 돌때마다 작은 while문의 반복이 1씩 줄어들기에, 스택과 큐의 처리구조와 크게 다를것이 없음)

해당 문제는 큐 자료구조에 대한 기초적인 이해를 필요로합니다.

큐 자료구조?

당신은 세금처리를 위해 은행에 와 있습니다. 대기표를 뽑고 먼저 온 사람들의 업무가 끝날때까지 기다렸다가, 전광판에 자신의 번호가 나와서야 업무를 처리할 수 있죠. 당신보다 늦게 온 사람이 먼저 불려나가는 일은 좀처럼 없습니다. 이처럼 먼저 들어온 것이 먼저 나가는 방식을 FIFO(First In First Out)라고 부르고, 이것의 대표격이 바로 큐(Queue)알고리즘입니다.

문제의 해결 순서.

저는 문제의 순서를 3단계로 나누었습니다 1.트럭이 존재한다면, 모든 트럭을 한칸씩 땡긴다. 2.만약 다리에 트럭이 존재하지 않고, 대기 트럭이 없을 경우 진행된 시간을 리턴. 3.다리에 존재한느 모든 트럭의 무게 + 대기 트럭의 첫번째의 무게가 다리의 무게제한보다 같거나 작을 경우, 맨 앞에 있는 대기트럭을 다리에 올림.

이것을 반복하는 것으로 문제를 해결했습니다.

문제의 해결 코드

#include <string>
#include <vector>

using namespace std;

bool on_truck(vector<int> bridge)//트럭이 올라와있는지 검사
{
    int i = 0;
    while (i < bridge.size())
    {
        if (bridge[i] > 0)
            return true;
        i++;
    }
    return false;
}

void move_truck(vector<int>* bridge)//트럭을 한칸씩 땡기는 함수.
{
    int i = 0;
    while (i < bridge->size() - 1)
    {
        (*bridge)[i] = (*bridge)[i + 1];
        i++;
    }
    (*bridge)[i] = 0;
}
int on_truck_weight(vector<int> bridge)//다리에 있는 모든 트럭의 무게를 리턴.
{
    int i = 0;
    int weight = 0;
    while (i < bridge.size())
    {
        weight += bridge[i];
        i++;
    }
    return weight;
}

int solution(int bridge_length, int weight, vector<int> trucks) {
    int answer = 0;
    int time = 0;
    vector<int> bridge(bridge_length);
    while (true)
    {
        if (on_truck(bridge))
            move_truck(&bridge);
        else if (trucks.size() < 1)
            return time;
        if (trucks.size() > 0 && (on_truck_weight(bridge) + trucks.front()) <= weight)
        {
            bridge.back() = trucks.front();
            trucks.erase(trucks.begin());
        }
        time++;
    }
    return time;
}

type %,c,s는 처리가 그렇게 어렵지 않아, 넘어가도록 한다.

type P의 처리.

p옵션은 들어온 포인터 변수의 주소를 16진수로 변환시켜 보여주는 타입이다. 이를 처리하기 위해 매개변수로 받은 가변인자를 long long자료형으로 변환시켜 사용한다. 사실상 방법은 그렇게 어렵지 않다. 기존에 정수형 10진수를 16진수로 변형시키는 x옵션이 있는데, 자료형만 바꿔 그 똑같이 문자열을 처리해주면 된다.

int            ft_print_type_pointer(t_format *t_form, va_list *va)
{
    char        *str;
    long long    p;
    int            i;

    i = 0;
    ft_putstr_fd("0x",1);//앞에 기본적으로 붙는 문자
    str = ft_lltoh((long long)va_arg(*va, long long));
    while (i < 12)
    {
        ft_putchar_fd(str[i],1);
        i++;
    }
    free(str);
    return (14);//%p가 리턴하는 문자열은 0x + 12개의 16진수로 항상 14개이다.
}

//unit은 서식지정자의 문자-23의 값. 어차피 x,X밖에 들어올 것이 없기 떄문에 거기서
//-23을 해주면 a또는 A가 나오게 된다.
char        *ft_itoh(unsigned int n, char unit)
{
    int        len;
    char    *c;

    len = ft_ulen(n, 16);//16진수로 변환할 숫자의 길이를 얻는 함수. 뒤에 붙는것은
      //10진법, 8진법에서도 사용할 수 있도록 몇진법인지를 명시해놓도록 했다.
    c = (char *)ft_calloc(len + 1, 1);
    if (c == NULL)
        return (0);
    c[len] = '\0';
    len--;
    while (len >= 0)
    {
        if (n % 16 < 10)
            c[len] = '0' + n % 16;//0~9
        else
            c[len] = unit + ((n % 16) - 10);//a~f,A~F
        len--;
        n /= 16;
    }
    return (c);
}

잘 나오고 있다

보통 우리가 쓰는 함수들은 매개변수의 개수가 정해져있어, 지정한 개수와 다른 인자를 넣게되면 오류를 뿜어낸다. 그렇다면 하나에 의문이 든다. 우리가 평소에 자주쓰는 printf또한 함수인데, 이는 어떻게 각종 타입의 변수를, 개수에 상관없이 넣을 수 있는 것인가?

그 해답은 바로 가변 인자에 있다.

가변 인자(variable argument)란?

가변 인자는 이름 그대로, 변할 수 있는 인자란 뜻이다. 아래 코드를 보자.

#include <stdio.h>
#include <stdarg.h>

void    PrintNumbers(int argc, ...)
{
    va_list ap;
    int     i;

    va_start(ap, argc);
    for (i = 0; i < argc; i++)
    {
        printf("%d ", va_arg(ap, int));
    }
    printf("\n");
    va_end(ap);
}

int main()
{

    PrintNumbers(1, 10);
    PrintNumbers(2, 10, 100);
    PrintNumbers(3, 10, 100, 1000);
    PrintNumbers(4, 10, 100, 1000, 10000);

    return 1;
}

가변 인자 매크로

va_start, va_arg, va_end얘네들에 대해 설명하기 전에 짚고 넘어갈 것은, 얘네들은 함수가 아닌 매크로라는 것이다. 비주얼 스튜디오에서는 함수를 노란색, 매크로를 보라색으로 표시하는데 이미지를 보면 가변 인자 관련된 녀석들은 모두 보라색인걸 알 수 있다.

va_start(ap,마지막 고정 인수)

이 명령은 가변 인수를 읽기 위한 준비를 하는데, ap가 첫번째 가변 인수를 가리키도록 초기화한다. 여기서 마지막 고정 인수라고 한 이유는 va_start내부에서 ap가 마지막 고정 인수 다음부터 가변 인수를 읽을 수 있기 때문이다.

va_arg(ap, 인수타입)

가변 인수를 실제로 읽어오는 매크로. va_start가 ap를 첫번째 가변 인수 번지로 맞춰주기 때문에, ap위치에 있는 값을 읽기만 하면 된다. 단, 인자로 들어온 값이 어떤 타입인지를 명시해주어야 이 매크로가 값을 제대로 읽을 수 있기에 두번째 인수로 읽고자 하는 값의 타입을 지정해준다. 변수의 타입을 매개로 전달할 수 있는 이유는 이가 매크로이기 때문이다. 내부적으로 sizeof연산자와 캐스트 연산자로 전달되기 때문에 타입명이 될 수 있다. 저렇게말이다.

va_end(ap)

가변인수를 읽는 것을 마치겠다는 명령. read후 close를 해주는 것과 비슷하다고 보면 된다.

가변 인수 함수의 조건

가변 인수를 활용한 함수를 제대로 작성하기 위해선 몇가지 조건이 필요하다.

1.가변 인수 함수는 반드시 하나 이상의 고정 인수를 가져야 한다. 왜냐면 가변 인수를 읽기 위한 포인터 ap를 초기화 하기 위해서 마지막 고정 인수의 번지를 알아야 하기 때문이다.

2.함수 내부에서 자신에게 전달된 가변 인수의 개수를 알 수 있도록 해야한다. 전달될 수 있는 인수의 개수에는 제한이 없으며 컴파일러는 함수가 호출될 때 인수의 개수를 점검하지 않는다. 그렇기때문에 호출하는 쪽에서 가변 인수의 개수를 알려주지 않으면 함수 내부에서는 인수의 개수를 알 수 있는 방법이 없다. 함수에서 인수의 갯수를 알 수 있도록 호출쪽에서 정보를 제공해야한다.

3.함수의 개수와 마찬가지로 가변 인수의 타입 또한 알 수 있어야한다. 2,3번을 대표적으로 보여주는것이 바로 printf인데, 예를 들어

printf("%s %d","HELLO WORLD!!!",15);

구문을 보면, 우리는 첫번째 인수에서 2개의 변수를 받고, 각각 문자열과 정수형 타입의 변수가 순서대로 들어간다는 정보를 함수에게 알려준 것이다.

참고한 자료 및 사이트

C언어 가변인자 코딩도장

A클래스 -> 1126까지의 값을 사용할 수 있음.(127은 제외됨) B클래스 ->128 ~ 191.255.255.255까지 쓸 수 있음. C클래스 ->192223.255.255.255까지 쓸 수 있음. 참고 : 네트워크에서 0은 호스트 부분이라는 뜻 호스트 주소가 가질 수 있는 값은? 네트워크 주소를 뺀 나머지의 -2 이다.예를 들어, C클래스의 호스트주소가 가질 수 있는 최대 개수는 2의 8승 -2이다.-2가 빠지는 이유는, 호스트의 모든 값이 1일 경우 브로드캐스트, 0일 경우 네트워크 주소로 사용하기 때문. 왜 필요한가?컴퓨터의 경우 각각 사용하는 운영체제가 달랐고, 프로그램의 경우 , 저마다 구현된 언어가 다르기 때문에, 이들이 서로 통신할 수 있는 공통된 프로토콜이 필요했다. 1960년대에는 저마다 다른 프로토콜을 사용하고 있었고, 다른 회사의 장비와는 통신이 힘들거나, 불가능했다. 이 때문에 국제표준화기구에서 1977년에 OSI 7계층 모델을 발표한다. OSI 7계층 모델에서, 3계층(네트워크 계승)에 위치하는 프로토콜이다.

호스트에서 호스트까지의 통신(즉, 보내는 컴퓨터와 받는 컴퓨터까지의 통신)을 책임진다. 간단하게 설명하면, 편지 봉투에 보내는 주소, 받는 주소를 작성하고 우표를 붙여서 우체통에 넣는 일과, 우편함에 들어온 편지를 꺼내서 나한테 온 편지가 맞는지 확인하는 정도의 작업이라고 생각하면 된다.

서브네팅이란? 네트워크의 관리자가 네트워크 성능을 향상시키기 위해 자원을 효율적으로 분배하는 것을 말한다.여기서 효율적으로 분배한다는 것은, 네트워크의 영역과 호스트 영역을 분할하는 것. 너무 큰 브로드캐스트 도메인은 네트워크 환경에서 패킷전송을 느리게하고, 성능을 저하시킨다. 따라서 네트워크를 쪼개성능을 보장하는 것을 의미함.

요약하자면 서브네팅 : 네트워크를 성능 항샹 및 자원의 효율적 분배를 위해, 네트워크 영역과 호스트 영역을 쪼개는 작업. ip : ip는 32자리로 이루어진 2진수, ip는 네트워크 영역과 호스트 영역으로 구성됨, 동일한 네트워크 내에서, 호스트 ip는 각자 달라야한다. 즉, 어떤 기관에서 배정받은 하나의 네트워크 주소를 다시 여러개의 작은 네트워크로 나누어 효율적이게 사용하는 방식을 말한다.

넷마스크, 서브넷 마스크란? 네트워크 내의 주소에 해당하는 IP 주소 중 네트워크를 식별하기 위해 몇 비트를 네트워크 주소에 사용할 지 정의하는 것이다.(마스킹)네트워크 ID부분과 호스트 ID부분을 구별해준다. 마스킹은 주의 : 서브넷 마스크는 1과 0으로 이루어져 있다. 중요한 것은, 여기서 1이 연속적으로 이뤄져야 한다는 것이다.예를 들어1111 = O1110 = O1001 = X0101 = X 서브넷 마스크는 ip의 뒤에 붙일 수 있다예를 들어 192.168.219.1/24 라고 하면, 이는 C클래스이고 디폴트 마스크는 255.255.255.0이다. ip의 /뒤에 붙는 숫자는바로 이 마스크의 1의 개수를 적어놓은 것. 만약 마스크가 255.255.255.128이라면 192.168.219.1/25가 된다. 위 이미지처럼, cmd에서 ifconfig를 치면 서브넷 마스크가 나온다.이는 192.168.219.1~192.168.219.255까지(255는 브로드캐스트 도메인) 곧 해당 서브넷의 네트워크란 뜻이다. 별개의 서브넷마스크를 생성하지 않아도, 기본적으로 적용되어 있는 것이 기본 서브넷마스크이고, 기본 서브넷마스크로 쪼개진 네트워크 주소를 서브넷 네트워크라고 한다.즉ip = 192.168.219.100서브넷 마스크 : 255.255.255.0서브넷 네트워크 : 192.168.219.0저 두개를 and연산하여 나온것이 아래 서브넷 네트워크라고 할 수 있다.