1.char * word = "hello" 이렇게되있을때, char * word = 0x12 이런식으로,

문자열의 주소값을 가지고있다고 생각해서 제가 이름값만 바로 넘겨버렸었거든요;
문자열의 주소값을 바탕으로 포인터로 접근하면 된다고생각했는데 안되더라구요 ㅠㅠ. 왜그런건가요 ㅠㅠ.? 왜, 문자열의 주소값이 아니라, 문자열을 가리키고있는 포인터의 주소를 이중포인터로 받아서 접근해야하는건가요??

 

 

2.배열의 경우엔 이름이 주소값이라서 저렇게 넘겨졌구요; 제가 개념이 꼬인거같은데 이부분 조금만 설명해주시면안될까요 ..?
c언어에서 문자열을 표현할때, 포인터로 표현할때와 배열의 표현할때 차이점을요 ㅠㅠ.



   테스트를 위하여, 문자열 연산을 싱글 포인터로 바꿔봤습니다. 
 



#include  
#include 
#include 
#include 
#include 

#define DICTIONARY_SIZE 30 
//단어를 랜덤으로 하나 고름 
void PickUpProblem(char *words[], char *word2);
//문제를 만들어냄( ex> apple -> _____) 
void MakeProblem(char * answer, char ** word);


int main(void)
{
    char * words[] = { "apple","banana","carrot","dog","egg","flash","inheritance","multimedia","console","printf",
        "best","initialization","constructor","structure","file","software","hardware","animal","zoo","vaccine",
        "matlab","cat","architect","toeic","computer","java","watch","samsung","brand","vitamin" };
    char * word = NULL;
    char answer[20];

    //단어를 랜덤으로 하나 고름 
    PickUpProblem(words, word);

    //고른 단어를 바탕으로 문제 제작 
    MakeProblem(answer, &word);

    return 0;
}

void PickUpProblem(char * words[], char * word2)
{
    int i;
    srand(time(NULL));
    word2 = words[rand() % DICTIONARY_SIZE];
}
void MakeProblem(char *answer, char **word)
{
    int i;

    for (i = 0; i < strlen(*word); i++)
    {
        answer[i] = '_';
    }

    answer[i] = '\0'; //문자열의 끝을 나타내는 널문자 삽입 
}

 

 해설 : 함수 인자는 Call by Value로 넘어갑니다. 

 
PickUpProblem() 함수의 인자인 word2 는 PickUpProblem() 함수의 "지역변수" 입니다. 즉, 함수가 끝나면 이 변수는 사라집니다. 휘발성입니다.

○ Main() 함수에서 PickUpProblem() 함수를 부르면서, main() 함수의 지역변수인 word 를 인자로 넘겼습니다. 하지만, word 변수 자체를 넘긴 것이 아니라, word 함수의 주소값만 넘긴 것입니다. "값" 만 넘긴 것입니다. (Call by Value)

○ 다음은 디버거를 이용하여, word와 word2 의 메모리 주소와, 그 값이 변하는 것을 찍어본 것입니다.


1. Main() 에서 PickUpProblem() 함수를 불렀을 때 입니다. word2 변수는 아직 호출되지 않아서 알 수 없습니다.NULL로 초기화 되어 있는 상태입니다.


2. PickUpProblem() 함수 안으로 들어와서 함수 실행이 막 끝난 상태입니다.



이 때, 메모리를 열어보면, word 변수는 변화가 없습니다.

처음에 PickUpProblem() 함수가 실행되었을 때, word2에다 word 변수의 메모리 주소만 적어놓은 것이기 때문입니다.

word2 = words[] 의 값을 할당하면서, 적어놓은 메모리 주소는 지워지고, 그 위에 "vaccine" 에 해당하는 주소가 저장됩니다.




이후, PickUpProblem() 함수 실행이 끝나면 word2 변수는 지역 변수이기 때문에 날아갑니다. 원래 main() 함수의 word 변수는 아무런 변화가 없습니다.



 

 이중 포인터를 쓰는 이유  

 
○ 문자열의 경우는, Char *word 를 문자열을 저장하는 하나의 변수로 생각하는 편이 이해가 쉽습니다. 즉, int A; 처럼 String word 를 선언한 것입니다. 즉, String = char* 인 것이죠.

그럼, String word의 참조를 함수의 인자로 전달하기 위해서는 String *word 를 전달해야 합니다.

○ String = char* 라고 했으니, 다시 치환하면 char **word 가 됩니다. 이해가 되실까요? 이걸 이해하면 포인터를 진짜로 이해한 것입니다.



 

 컴퓨터 메모리의 주소와 값을 구분해서 이해할 수 있어야 합니다.  이부분이 제일 어렵습니다

 
○ 다른 방식으로 풀 수도 있습니다. 위에 예제에서, word 변수의 주소값을 인자로 넘겼습니다. 위 예제에서는 이 주소값을 활용하지 않았습니다. 

○ strcpy(word2, words[rand()%DICTIONARY_SIZE])를 호출하면 문제가 해결됩니다. word2의 주소에다 words[]의 문자열 (여기서는 vaccine) 를 직접 써넣는 함수 입니다. 이중 포인터를 쓰는 것에 비하면 값을 카피하는 시간이 걸리기 때문에 비효율적입니다.



Posted by 지그프리드 지그프리드

출력값 알아내는게 문제인데요

출력값 첫번째는 30이고 두번째는 a부터 i까지 출력돼야 되는거 아닌가요?

두번째는 쓰레기값도 아니고 뭔 이상한 한자같은게 나오는데 원래 이렇게 나오는게 맞나요?



 

 Debug : For 문에 불필요한 세미 콜론이 있어서 오류입니다.   

 

○ 질문하신 코드의 For Loop에 잘못된 세미 콜론이 있습니다. 이 때문에 For 문이 진행이 안되었습니다. 



 

 코드 개선  

 

○ 물론, 예제 코드라서 그랬겠지만, 코드에 잘못된 부분이 많습니다. 

○ Malloc() 을 쓸 때는 Sizeof() 와 함께 써야 시스템이 바뀌어도 오류없이 동작합니다. 원래 코드는 위험합니다. 

○ Malloc() 후에는 메모리를 리셋해 주는 것이 좋습니다. (이 부분은 생략)

○ 문자열을 다룰 때는 마지막에 Null 문자를 넣어 주어야, 출력할 때 쓰레기 값이 보이지 않게 됩니다. 



   예제 코드
 

#include 
#include 

int main()
{
	int i = 0;
	int* pTmp = (int*)malloc(sizeof(int) * 10);
	char* pCh = (char*)malloc(20);

	pTmp[0] = 10;
	pTmp[1] = 20;

	printf("Sum : %d\n", pTmp[0] + pTmp[1]);

	for (i; i < 10; i++)
	{
		pCh[i] = 0x61 + i;
	}

	pCh[i] = '\0'; //Null char at the End of string

	printf("%s \n", pCh);

	free(pTmp);
	free(pCh);

	return 0;
}

 

 실행 결과  

 








Posted by 지그프리드 지그프리드
#include 

using namespace std;

class CObj
{
    private:
        const int m_iValue;
        const short m_sValue;

        int m_iTest;
    public:
        int*  GetTest(void) const                 //1번 함수
        {
            return &m_iTest;
        }

        int* const GetTest2(void)
        {
            return &m_iTest;                // 2번 함수
        }
};

int main(void)
{

    return 0;
}


1번 함수는 왜 오류가 나는 건가요??  그리고 nt*  const  GetTest(void)   이렇게도 되는데 

이건 무슨 의미 인가요???



 

 Const 선언의 위치는 알아보기 쉽게 맨 앞으로 해주세요 

 

1. int*  GetTest(void) const 
    이게 별로 좋은 선언 방법은 아닙니다 (엄밀히는 틀렸습니다.) Visual Studio 2015 컴파일러는 다행히 이것을 
    const  int*  GetTest(void)  와 동일하게 처리해주고 있습니다. 

    따라서, GetTest() 함수의 return 값으로 const int* 를 기대했는데, 보통의 int* 가 리턴이 되니까 컴파일 에러가 나는 겁니다. 

2. Test 2도 마찬가집니다. 가운데에 const가 들어간 경우에도  const  int*  GetTest(void) 와 동일하게 처리합니다. 
   이 내용은 제가 참고한 설명 링크에도 const의 위치에 따른 두가지 경우를 동일하게 언급이 있습니다. 
   
헛갈리게 짜는 건 무조건 잘못된 일입니다. const는 GetTest2() 처럼 정확한 위치에 두세요.


Posted by 지그프리드 지그프리드
두 정수의 최대공약수를 구하는 코드입니다.
뭐가 문제인지 잘 모르겠습니다.

왜 고쳐야 하는지하고 어떻게 고쳐야 하는지 알려주시면 감사하겠습니다.


 

 코드의 세세한 실수가 많네요  

 

○ Scanf() 함수의 입력 포멧 ("%d%d") 사이에 여백이 있어야 합니다. 이대로는 3, 36, 3 6 을 구분할 수 없습니다. 

○ 두 숫자가 같은 것을 확인하는 부분은 (a == b) 입니다. 여기가 (a = b) 로 되니, 이 부분만 지나면 a, b 값이 똑같아 지고, 이후 부분은 건너뛰게 됩니다. 

○ 출력 부분에 "%d" 가 없으니, c 를 출력할 수가 없습니다 .Printf() 함수 사용법을 더 명확하게 보세요

○ 최대공약수를 못찾는 경우에 대한 예외처리 추가해주세요



   코드 예제  
 

#include

int main()
{
    int a = -1, b = -1, c = -1;
    printf("두 정수를 입력하시오");
    scanf("%d %d", &a, &b);

    if (a > b)
    {
        c = a - 1;
        while (c > 1)
        {
            if (a%c == 0)
            {
                if (b%c == 0)
                {
                    printf("두 정수의 최대공약수 : %d\n", c);
                    break;
                }
            }

            c--;
        }
    }
    else if (a == b)
    {
        printf("두 정수의 최대공약수 : %d\n", a);
    }
    else
    {
        c = b - 1;
        while (c > 1)
        {
            if (b%c == 0)
            {
                if (a%c == 0)
                {
                    printf("두 정수의 최대공약수 :%d\n", c);
                    break;
                }
            }

            c--;
        }
    }

    if (c == 1)
    {
        printf("최대공약수가 없습니다\n");
    }

    getchar();	//Just for screen break
    return 0;
}


   실행 결과  
 





Posted by 지그프리드 지그프리드

c언어 재귀함수 연습 원인좀 알려주세요.


재귀함수로 반복문 연습해보는중인데 저가 원하는 출력문은

*****

****

***

**

*

이렇게 나오는것인데 저위에 코드대로 해보면

*****

****

***

**

*

*****

출력문이 이런형태로 나오게되는데 원인좀 알려주세요!.

왜  한번더 돌게 되는지 설명좀 해주세요.



   일단 완전 잘못 짰습니다.  
 

○ for_1 함수 중간에 main() 함수를 다시 호출하는 것부터 완전 잘못된 코드입니다. 이것은 재귀함수가 아닙니다. 

○ 코드를 고쳐줄까하고 보다가, 너무 모르는 것이 많은 것 같아서, 완전히 다시 짜서 올립니다. 


1. 코드가 컴파일되서 돌지도 않습니다. 예를 들어, for_1() 함수의 return을 int 형으로 선언하셨는데, 실제로는 end==0 인 케이스에서 return; 만 하고 있습니다. 

2. main() 함수를 다른 함수에서 다시 호출하는 것은 절대 안됩니다. 

3. 함수 이름, 변수 이름을 의미 없게 짓는 것은 피하셔야 합니다. 

4. static 선언도 재귀함수의 원래 의도와 맞지 않습니다.



 

 코드 예제 

 

#include 

void printStar(int n);

int main() {
    printStar(5);	//Print Star

    getchar();		//Just for break

    return 0;
}

void printStar(int n)
{
    int i;

    if (n > 0)
    {
        for (i = 0; i < n; i++)
        {
            printf("*");
        }
        printf("\n");

        printStar(n - 1);	//Recusive Call
    }
    else
    {
        return;
    }
}




   실행 결과  
 








Posted by 지그프리드 지그프리드

피보나치 수열 재귀함수 이용하지 않고

비재귀로 하는방법 좀 알려주세요~~


일단 재귀함수 이용하는건 했는데

비재귀는 어떻게 해야되는지 모르겠네요.. 더쉬울줄알았는데..

// 제가 작성한 피보나치 재귀함수 이용 버전입니다.



 

 Stack을 사용하면 됩니다 

 

○ 재귀함수를 없애는 가장 기본적인 방법은 Stack을 사용하는 것입니다. 재귀함수 자체가 실제로는 함수 Stack에 차곡차곡 결과값을 쌓고 있는 것입니다. 실제 Stack을 이용해서 값을 저장하면 그만입니다. 


○ 특히 피보나치수열의 경우는 진짜 Stack을 쓸 필요도 없고, Stack 처럼 동작하는 Array면 됩니다. 제 코드에서도 Pop() 함수는 작성을 했지만, 막상 부르는 곳이 없습니다. 지우기도 귀찮아서 일단 남겨둡니다. 


○ 참고로, 이 피보나치 수열은 0부터 시작하는 피보나치 수열입니다. 즉, 0, 1, 1, 2, 3, 5  순서로 진행됩니다. Wikipedia에 이것이 현대적인 형태라고 하더군요

https://en.wikipedia.org/wiki/Fibonacci_number



   코드 예제  
 

#include 
using namespace std;

/* stack */
int stack[100];
int top = -1;
int loop;
int push(int inputV);
int pop(void);

int fibonacciOne(int x);

int main()
{
    //피보나치 수열 재귀
    int n;
    cout << "몇번째 항의 값을 원합니까?";
    cin >> n;
    cout << "\n" << n << "번째 항은 " << fibonacciOne(n) << "입니다.";
    cin >> n;

    return 0;
}

int push(int inputV)
{
    if (top >= 99) //stack is full
    {
        return -1;	//Error
    }
    else
    {
        stack[++top] = inputV;
    }
}

int pop(void)
{
    if (top < 0)
    {
        return -1;	//Error
    }
    else
        return stack[top--];
}


int fibonacciOne(int x)
{
    /* init stack */
    for (loop = 0; loop < 100; loop++)
    {
        stack[loop] = 0;
    }
    top = -1;

    /* Set first two number of fibonacci array*/
    stack[0] = 0;
    stack[1] = 1;

    /* calculate Nth number */
    if (x <= 0)
    {
        return -1;	//Error
    }
    else if ((x == 1) && (x == 2))
    {
        return stack[x - 1];
    }
    else if (x >= 100) //too big for demo
    {
        cout << "Error\n";
        return -1;
    }
    else   //Normal case
    {
        for (loop = 2; loop < x; loop++)
        {
            stack[loop] = stack[loop - 2] + stack[loop - 1];
        }

        /* show all array */
        for (int loop = 0; loop < x; loop++)
        {
            cout << stack[loop] << " ";
        }

        return stack[x - 1];
    }
}



   실행 결과 
 





Posted by 지그프리드 지그프리드

질문 제목 :  배열 구조체를 이용한 성적출력

 

 

질문 요약 :   과목별로 성적을 출력하여 내림차순을 시키는 방법

 

 

질문 내용 :   아래함수 부분에서 down_stand함수에 내림차순을 시키는겁니다.

                  학교에서 자면서 열심히 연구했는데 도저히 안떠오르네요.ㅠㅠ

                  도와주세요...ㅠㅠ힌트라도..제발~ㅠㅠ


 Code Example:


/* Written by rinehart@naver.com         */
/* 2009. 2. 10.                                    */
/* Tested on Windows, Cygwin, gcc      */
/* This code example is very very ugly*/
/* It's originaly written by a questioner */
/* My code is the function : down_stand*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

struct grade
{
    char sub[5];
    char name1[10];
    char name2[10];
    char name3[10];
    char name4[10];
};

typedef struct grade grade;

void grade_prt(grade score[]); //성적표 출력함수
void grade_score(grade score[], char subject[]); //과목별 개인 점수
void down_stand(grade score[], char subject[], int i);


/****************************************************************/


int main()
{
    int i=0;
    char subject[5];

    grade score[5]= {{"   ","김태희", "한가인", "손예진", "이지아"},
                    {"국어", "80", "100", "10", "95"},
                    {"영어", "100", "100", "15", "85"},
                    {"수학", "90", "85", "75", "35"},
                    {"과학", "75", "90", "65", "25"}};

    grade_prt(score); //성적표 출력함수
   
    while(1) //종료를 위함
    {
        printf("\n***************************************\n\n");
        printf("**종료하고싶으시면 x 를 입력하세요.**\n\n");
        printf("<과목을 입력해주세요.>\n");

        memset(subject, 0x00, sizeof(char)*5);
        gets(subject);

        if(subject[0]=='x')
            break;

        printf("\n--> (%s)  과목의 개인별 점수는?\n", subject);
        grade_score(score, subject); //과목별 개인 점수
    }

    return 0;
}


/****************************************************************/


void grade_prt(grade score[]) //성적표 출력함수
{
    int i=0;

    for(; i<=4; i++)
    {
        printf("%5s | %6s | %6s | %6s | %6s\n",
                score[i].sub,
                score[i].name1,
                score[i].name2,
                score[i].name3,
                score[i].name4);
    }
}


/****************************************************************/


void grade_score(grade score[], char subject[]) //과목별 개인 점수
{
    int i, j, k=0;

    for(i=0; i<=5; i++) //score[i].sub선택
    {
        for(j=4; j>=0; j-- ) //과목 비트비교
        {
            if(score[i].sub[j] == subject[j])
                k++;
        }

        if(k==5)
        {
            down_stand(score, subject, i); //내림차순 정렬
        }

        k=0;
    }
}

/****************************************************************/
void down_stand(grade score[], char subject[], int m) //내림차순 정렬
{
    int i, j;

    typedef struct new_grade
    {
        char name[10];
        int score;
    }new_grade;

    new_grade New_Grade[4] = {  {"김태희", 0},
                                {"한가인", 0},
                                {"손예진", 0},
                                {"이지아", 0}
    };

    struct new_grade s_temp;    //for sorting

    //initialize new_grade array.
    New_Grade[0].score = atoi(score[m].name1);
    New_Grade[1].score = atoi(score[m].name2);
    New_Grade[2].score = atoi(score[m].name3);
    New_Grade[3].score = atoi(score[m].name4);

    // Bubble Sorting
    for (i = 3; i > 0; i--)
    {
        for (j= i; j > 0; j--)
        {
            if (New_Grade[j].score > New_Grade[j-1].score)  //Bigger one switch to foward
            {
                memset(&s_temp, 0x00, sizeof(new_grade));
                memcpy(&s_temp, &New_Grade[j-1], sizeof(new_grade));
                memcpy(&New_Grade[j-1], &New_Grade[j], sizeof(new_grade));
                memcpy(&New_Grade[j], &s_temp, sizeof(new_grade));
            }
        }
    }

    // Print out
    printf("%5s | %6s | %6s | %6s | %6s\n", score[0].sub,
            New_Grade[0].name, New_Grade[1].name, New_Grade[2].name, New_Grade[3].name);
           
    printf("%5s | %6d | %6d | %6d | %6d\n", score[m].sub,
            New_Grade[0].score, New_Grade[1].score, New_Grade[2].score, New_Grade[3].score);
}


Posted by 지그프리드 지그프리드

10진수를 입력받아 2진수로 변환한 후 이 수보다 큰 수 중 가장 작은 수를 구하여라.

단, 주어진 수를 2진수로 변환하였을 때 1의 개수와 구하는 큰 수의 1의 개수는 같아야 한다.

단, 주어진 정수는 1보다 크거나 같고 1000000보다 작거나 같다

 

예)

입력 : 1

출력 : 2

 

입력 : 4

출력 : 8

 

입력 : 78

출력 : 83


Find next biggest binary number. Condition : Number of 1 should be same between input & output.


/* Written by rinehart@naver.com     */
/* 2009. 2. 10.                                */
/* Tested on Windows, Cygwin, gcc  */

#include <stdio.h>

int main(void)
{
    int     v_input = 0;
    int     v_temp = 0;
    int     v_output = 0;
    int     v_nb_of_1_input = 0;
    int     v_nb_of_1_output = 0;   
    int        i = 0;

    // input number
    printf ("Input devimal number : ");
    scanf("%d", &v_input);

    // check input
    if (v_input < 1 || v_input > 1000000)
    {
        printf ("Wrong number.\n");
        return -1;
    }

    //Make binary & count number of 1
    v_temp = v_input;
   
    while (v_temp > 0)
    {
        if (v_temp % 2)        //Is ther 1?
            v_nb_of_1_input++;    //counting
           
        v_temp = v_temp/2;
    }

    //Find next biggest number : Same number of 1
    v_output = v_input +1;
   
    while (v_output < 1000000)
    {
        v_temp = v_output;
        v_nb_of_1_output = 0;

        while (v_temp > 0)
        {
            if (v_temp % 2)     //Is ther 1?
                v_nb_of_1_output++;    //counting
               
            v_temp = v_temp/2;
        }

        //Are number of 1 values same?
        if (v_nb_of_1_input == v_nb_of_1_output)
            break;    //Exit while loop

        v_output++;
    }
   
    // print out the result
    printf ("Result : %d\n", v_output);

    return 0;
}


Posted by 지그프리드 지그프리드
 int 형을 이용해서는 2의 31승 까지만 표현할 수 있습니다. Char 배열을 이용해서 이보다 더 큰 수를 계산해 봅시다. 예제는 2의 100승 입니다.

/* Written by rinehart@naver.com      */
/* 2009. 2. 9.                                   */
/* Tested on Windows, Cygwin, gcc  */

#include <stdio.h>

#define MAX (100)
#define TRUE    1
#define FALSE   0

int main()
{
    char    a_Result[MAX];
    int v_input = 0;
    int i = 0, j= 0; //Loop
    int b_first_non_zero = FALSE;   //To avoid straight Zero print out.

    memset (a_Result, 0x00, MAX);

    printf ("Input Power number : " );    // Get an input number
    scanf ("%d", &v_input);

    if (v_input > MAX || v_input < 0)    // input check
    {
        printf ("Wrong number\n");
        return 0;   //Quit program.
    }

    if (v_input >= 0)
    {
        a_Result[0] = 1;    // 2 power 0 is always 1. And Initialze a_Result.
    }

    //Calculation loop
    for (i = 0; i < v_input; i++)  
    {
        int v_temp = 0;
        int v_carry_before = 0;
        int v_carry_over = 0;

        for (j = 0; j < MAX-1; j++) //MAX -1 : to avoid overflow.
        {
            v_temp = a_Result[j];  
            v_temp = v_temp * 2;    // x2 to each digit.
            v_carry_before = v_carry_over;
            v_carry_over = 0;

            if (v_temp > 9)
            {
                v_carry_over = 1;
                v_temp -= 10;
            }

            a_Result[j] = v_temp +v_carry_before ;
            v_carry_before = 0;
        }
    }

    printf ("The Result of 2 power v_input is \n");    // Result print routine.

    for (i = MAX-1; i >= 0; i--)
    {
        if (a_Result[i] != 0)
        {
            b_first_non_zero = TRUE;
            printf("%d", a_Result[i]);
        }
        else if ((a_Result[i] == 0) && (b_first_non_zero == TRUE))
        {
            printf("%d", a_Result[i]);
        }
    }
   
    printf (".\n");

    return 0;
}

Posted by 지그프리드 지그프리드

x,y의 좌표가 주어졌을때

각도 구하는 코딩 가르쳐주세요!!

x, y 좌표를 이용해서 좌표축에 만들어지는 삼각함수를 이용하면 됩니다.

각도를 A 라고 하면, tan(A)  = y/x 가 되지요.  반대로, x, y 좌표를 이용해서 각도 A를 구하는 것은 역함수 아크탄젠트를 이용하면 됩니다. 자세한 수학적 이론은 정석의 삼각함수를 찾아보세요.

C 언어 라이브러리 중에 math.h 가 있습니다. 삼각함수를 제공합니다.

함수 설명은 http://www.cplusplus.com/reference/clibrary/cmath/atan2.html 여기를 참조하시고요, 예제코드는 아래 있습니다.

Example

/* atan2 example */
#include
#include

#define PI 3.14159265

int main ()
{
double x, y, result;
x = -10.0;
y = 10.0;
result = atan2 (y,x) * 180 / PI;
printf ("The arc tangent for (x=%lf, y=%lf) is %lf degrees\n", x, y, result );
return 0;
}

Output:


The arc tangent for (x=-10.000000, y=10.000000) is 135.000000 degrees.
Posted by 지그프리드 지그프리드

BLOG main image
일상, 프로그래밍, IT 그리고 직장생활, Dive, 여행 by 지그프리드

카테고리

Class List (402)
Studies (30)
Exercise & Quizz (10)
Term Project (0)
ECIM list (Help!) (10)
Issues & News (0)
Gossip about IT & Job (22)
Tools (2)
Think about the Justice (23)
Book Review (170)
조엘 온 소프트웨어(번역) (28)
Diary (87)
Vacations (9)
Clash of clans 클래시 오브.. (11)

글 보관함

달력

«   2019/09   »
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          
Total : 314,068
Today : 0 Yesterday : 18