반응형

안녕하세요.

코딩을 하다 보면 시간에 관련된 함수를 많이 사용하게 됩니다.

항상 구글링으로 찾아보았었는데, 이번 기회에 한번 정리해봅니다.

공통으로 헤더 파일은 time.h를 포함시켜줘야 합니다.

 

time

현재시간을 time_t로 리턴합니다.

함수 원형

time_t time(time_t*  _Time);

반환형도 있고, 리턴 값도 있습니다. 리턴 값으로 받아도 되고, 파라미터에 time_t변수의 포인트를 넘겨서 받을 수도 있습니다.

time_t는 32비트 플랫폼에서는 long으로 64비트 플랫폼에서는 __int64로 typedef 되어 있습니다.

예제

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif
 
#include <stdio.h>
#include <time.h>
 
void main()
{
    time_t t = 0;
    t = time(NULL);        // time(&t);로 해도 같습니다.
    printf("%lld\n", t);
}
cs

 

localtime

time_t타입을 이용해서 tm구조체로 만듭니다.

tm구조체는 멤버 변수로 년, 월, 날, 시간, 분, 초가 있어서 현재시간을 명확하게 알 수 있게 해 줍니다.

 

함수 원형

struct tm * localtime(const time_t * _Time)

예제

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif
 
#include <stdio.h>
#include <time.h>
 
void main()
{
    struct tm* pTimeInfo;
    time_t t = time(NULL);
    pTimeInfo = localtime(&t);
 
    int year = pTimeInfo->tm_year + 1900;    //연도에는 1900 더해줌
    int month = pTimeInfo->tm_mon + 1;    // 월에는 1 더해줌
    int day = pTimeInfo->tm_mday;
    int hour = pTimeInfo->tm_hour;
    int min = pTimeInfo->tm_min;
    int sec = pTimeInfo->tm_sec;
 
    printf("%d-%.2d-%.2d %.2d:%.2d:%.2d\n", year, month, day, hour, min, sec);
}
cs

asctime

tm 구조체를 읽어 들여서 Www Mmm dd hh:mm:ss yyyy 형식으로 스트링 리턴합니다.

함수 원형

char * asctime(_In_ const struct tm * _Tm);

예제

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif
 
#include <stdio.h>
#include <time.h>
void main()
{
    struct tm* pTimeInfo;
    time_t t = time(NULL);
    pTimeInfo = localtime(&t);
 
    printf("%s", asctime(pTimeInfo));
}
cs

 

gmtime

time_t를 파라미터로 받아 UTC 시간을 리턴합니다.

함수 원형

struct tm * gmtime(const time_t * _Time)

예제

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
#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif
 
#include <stdio.h>
#include <time.h>
 
void main()
{
    struct tm* pTimeInfo;
    time_t t = time(NULL);
    pTimeInfo = gmtime(&t);
 
    int year = pTimeInfo->tm_year + 1900;    //연도에는 1900 더해줌
    int month = pTimeInfo->tm_mon + 1;    // 월에는 1 더해줌
    int day = pTimeInfo->tm_mday;
    int hour = pTimeInfo->tm_hour;
    int min = pTimeInfo->tm_min;
    int sec = pTimeInfo->tm_sec;
 
    printf("UTC %d-%.2d-%.2d %.2d:%.2d:%.2d\n", year, month, day, hour, min, sec);
    hour = hour + 9;
    if (hour >= 24)
    {
        day++;
        hour -= 24;
    }
        
    printf("KST %d-%.2d-%.2d %.2d:%.2d:%.2d\n", year, month, day, hour, min, sec);
}
cs

 

mktime

tm구조체를 이용해서 time_t타입으로 만듭니다.

함수 원형

time_t mktime(struct tm * _Tm)

예제

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif
 
#include <stdio.h>
#include <time.h>
 
void main()
{
    struct tm* pTimeInfo;
    time_t t1 = time(NULL);
    pTimeInfo = localtime(&t1);
 
    pTimeInfo->tm_mday = pTimeInfo->tm_mday + 7;
 
    time_t t2 = mktime(pTimeInfo);
 
    printf("time : %d\n", t1);
    printf("7 days later %d\n", t2);
    printf("t2-t1 : %d\n", t2 - t1);
}
cs

현재 시간과 7일 후 시간의 차를 계산해보는 예제입니다.

1분을 초로 변환하면 60 

시간을 초로 변환하면 60 X 60 = 3,600

하루를 초로 변환하면 60 X 60 X 24= 86,400

7일을 초로 계산하면 60 X 60 X 24 X 7= 604,800

 

기타로 mktime함수를 실제로 구현해보았습니다.

특정 시간 time_t로 지정한 후 tm구조체에 넣은 후 다시 time_t로 변경해보았습니다.

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
#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif
 
#include <stdio.h>
#include <time.h>
 
 
int GetMinToSec(int nMin);
int GetHourToSec(int nHour);
int GetDayToSec(int nDay);
int GetMonthToSec(int nMonth);
int GetYearToSec(int nYear);
void main()
{
    time_t t;
    struct tm* pTimeInfo;
    //t = time(NULL);
    t = 1620716583;
    pTimeInfo = localtime(&t);
 
    int year = pTimeInfo->tm_year + 1900;    //연도에는 1900 더해줌
    int month = pTimeInfo->tm_mon + 1;    // 월에는 1 더해줌
    int day = pTimeInfo->tm_mday;
    int hour = pTimeInfo->tm_hour;
    int min = pTimeInfo->tm_min;
    int sec = pTimeInfo->tm_sec;
 
    time_t nTime = sec + GetMinToSec(min) + GetHourToSec(hour - 9+ GetDayToSec(day) + GetMonthToSec(month - 1+ GetYearToSec(year - 1970);
 
    printf("%d-%.2d-%.2d %.2d:%.2d:%.2d\n", year, month, day, hour, min, sec);
    printf("%lld", nTime);
}
 
int GetMinToSec(int nMin)
{
    return nMin * 60;
}
int GetHourToSec(int nHour)
{
    return nHour * 3600;    // nHour * 60 * 60
}
int GetDayToSec(int nDay)
{
    return nDay * 86400;        // nDay * 60 * 60 * 24
}
int GetMonthToSec(int nMonth)
{
    int nMonthDay[12= { 312831303130313130313031 };    // Number of days per month
 
    int nMonthDayCount = 0;
 
    for (int i = 0; i < nMonth; i++)
        nMonthDayCount += nMonthDay[i];
 
    return nMonthDayCount * 86400;    // nMonthDayCount * 60 * 60 * 24
}
 
int GetYearToSec(int nYear)
{
    int nAddDay = nYear / 4;
 
    return  GetMonthToSec(12* nYear + nAddDay * 86400;    // GetMonthToSec(12) * nYear + nAddDay * 60 * 60 * 24
}
cs

지정한 1620716583과 같은 값이 출력되는 것을 확인할 수 있습니다.

반응형
반응형

안녕하세요.

오늘은 문자가 숫자인지를 확인하는 함수에 대해 알아보도록 하겠습니다.

문자가 숫자('0'~'9')인지를 확인하는 함수입니다.

함수 원형
int isdigit(int _C);
_C가 숫자인지를 판별합니다.

헤더파일
ctype.h

리턴값
숫자이면 0이 아닌값을 리턴합니다.( 4를 리턴 합니다)
숫자가 아니면 0을 리턴합니다.

예제

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <ctype.h>
 
void main()
{
    char chString[] = "a1-2+&ZY8b";
    
    for (int i = 0; chString[i] != '\0'; i++)
    {
        if (isdigit(chString[i]))
            printf("digit : %c\n", chString[i]);
        else
            printf("not digit : %c\n", chString[i]);
    }
}
cs

결과

isdigit함수를 사용하지 않고 구현하려면 다음과 같이 구현합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <ctype.h>
 
void main()
{
    char chString[] = "a1-2+&ZY8b";
        
    for (int i = 0; chString[i] != '\0'; i++)
    {
        if ((chString[i] >= '0' && chString[i] <= '9'))
            printf("digit : %c\n", chString[i]);
        else
            printf("not digit : %c\n", chString[i]);
    }
}
cs
반응형
반응형

안녕하세요.

오늘은 C언어에서 문자가 알파벳이거나 숫자인지 확인하는 함수에 대해 알아보로독 하겠습니다.

문자가 특수문자가 아닌 알파벳('a'~'z', 'A'~'Z')과 숫자('0'~'9')인지를 확인할 때 사용할 수 있습니다.

함수 원형
int isalnum( int _C );
_C가 알파벳이거나 숫자인지를 판별하게 됩니다.


헤더파일
ctype.h


리턴값
알파벳이거나 숫자이면 0이 아닌 값을 리턴합니다.(알파벳 대문자 : 1, 알파벳 소문자 : 2, 숫자 : 4를 리턴합니다.)
알파벳이거나 숫자가 아니면 0을 리턴합니다.

예제

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <ctype.h>
 
void main()
{
    char chString[] = "a1-2+&ZY8b";
    
    for (int i = 0; chString[i] != '\0'; i++)
    {
        if (isalnum(chString[i]))
            printf("alphanumeric : %c\n", chString[i]);
        else
            printf("not alphanumeric : %c\n", chString[i]);
    }
}
cs

 

isalnum함수를 사용하지 않고 직접 구현하려면 다음과 같이 구현하면 됩니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
#include <ctype.h>
 
void main()
{
    char chString[] = "a1-2+&ZY8b";
        
    for (int i = 0; chString[i] != '\0'; i++)
    {
        if ( (chString[i] >= 'a' && chString[i] <= 'z'
            || (chString[i] >= 'A' && chString[i] <= 'Z'
            || (chString[i] >= '0' && chString[i] <= '9'))
            printf("alphanumeric : %c\n", chString[i]);
        else
            printf("not alphanumeric : %c\n", chString[i]);
    }
}
cs
반응형
반응형

안녕하세요.

C언어에서 문자가 알파벳인지 아닌지 확인해주는 함수에 대해 알아보도록 하겠습니다.

캐릭터명이 알파벳으로만 만들어졌는지 확인할 때 유용합니다.

함수 원형
int isalpha( int _C );
_C가 문자 알파벳인지 판별하게 됩니다.

헤더 파일
ctype.h

리턴값
알파벳이면 0이 아닌 값(true), 대문자는 2, 소문자는 1
알파벳이 아니면 0(false)

예제

간단하게 문자를 하나씩 isalpha함수 파라메터에 넣어서 알파벳인지 판별합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <ctype.h>
 
void main()
{
    char chString[] = "a-+&b";
    
    for (int i = 0; chString[i] != '\0'; i++)
    {
        if (isalpha(chString[i]))
            printf("alpha : %c\n", chString[i]);
        else
            printf("not alpha : %c\n", chString[i]);
    }
}
cs

 

isalpha함수를 이용하지 않고 직접 구현해볼 수 도 있습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <ctype.h>
 
void main()
{
    char chString[] = "a-+&b";
 
    for (int i = 0; chString[i] != '\0'; i++)
    {
        if ((chString[i] >= 'a' && chString[i] <= 'z'|| (chString[i] >= 'A' && chString[i] <= 'Z'))
            printf("alpha : %c\n", chString[i]);
        else
            printf("not alpha : %c\n", chString[i]);
    }
}
cs
반응형
반응형

안녕하세요

만약 게임에서 몬스터가 랜덤한 위치에 나오게 하거나,
상자를 열었을 경우 랜덤하게 아이템이 나오게 하려면 어떻게 구현을 해야할까요??
오늘은 이러한 경우에 난수(Random)값을 추출하는 함수에 대해 이야기하려고 합니다.

 

rand

함수 원형
int rand();

헤더 파일
stdlib.h

리턴값
0에서 32,767까지 값이 리턴됩니다.
0~RAND_MAX(0~32767) 
RAND_MAX값이 32767(16진수로 0x7fff)로 정의되어있습니다.

예제

1
2
3
4
5
6
7
8
#include <stdio.h>
#include <stdlib.h>
 
void main()
{
    for ( int i = 0; i < 10; i++ )
        printf("%d\n", rand());
}
cs

문제점
예제를 여러번 실행해보면 항상 값이 같다는 것을 확인할 수 있습니다.
프로그램이 실행될 때마다 rand함수 호출 시 다른 값을 호출하기 위해서는 srand함수를 이용해야합니다.

srand

함수 원형
void srand(unsigned int _Seed);

헤더 파일
stdlib.h

리턴값
없습니다.

설명
Seed를 다른 값을 넣어주면 rand호출 시 마다 다른 값을 리턴해줄 수 있습니다.
시드에 상수를 넣어버리면 의미가 없기 떄문에 time함수를 넣어서 시간마다 다른 시드가 들어가도록 합니다.
time함수를 사용하기 위해서는 time.h 헤더파일을 추가해줘야합니다.

예제

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void main()
{
    srand((unsigned)time(NULL));
    for ( int i = 0; i < 10; i++ )
        printf("%d\n", rand());
}
 
cs

 

응용하기

1~3 랜덤값 추출하기
rand값에 3으로 나눈 나머지를 구하면 0~2까지 값이 나오고 여기서 1을 더해줍니다.

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void main()
{
    srand((unsigned)time(NULL));
    for ( int i = 0; i < 10; i++ )
        printf("%d\n", rand()%3+1);
}
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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void main()
{
    srand((unsigned)time(NULL));
    int nResult[10= { 0, };
    int nCount = 0;
    int nNum = 0;
    bool bExist = false;
    while(nCount < 10 )
    {
        bExist = false;
        nNum = rand() % 10 + 1;
        for (int i = 0; i < 10; i++)
        {
            if (nNum == nResult[i])
                bExist = true;
        }
 
        if (!bExist)
        {
            nResult[nCount++= nNum;
        }
            
    }
    for ( int i = 0; i < 10; i++ )
        printf("%d\n", nResult[i]);
}
cs

 

반응형
반응형

안녕하세요.

vecter에서 특정 데이터를 삭제할 때는 erase를 사용합니다.

간단하게 다음과 같이 삭제하면 될거같은데, 에러가 발생합니다.

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 <stdio.h>
#include <vector>
using namespace std;
 
void main()
{
    vector<int> v;
 
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
 
    for (vector<int>::iterator iter = v.begin(); iter != v.end(); ++iter)
    {
        if ( *iter == 3 )
        {
            v.erase(iter);
        }
    }
 
    for (vector<int>::iterator iter = v.begin(); iter != v.end(); ++iter)
    {
        printf("%d\n"*iter);
    }
    printf("size : %d\n", v.size());
}
cs

 

vector 이터레이터(iterator)가 더이상증가할 수 없다고 나옵니다.

 

해결 코드

earse후에 반환되는 이터레이터(iterator)가 있습니다.
erase후 반환 이터레이터(iterator)를 넣어줍니다.

v.erase(iter);

이렇게 변경합니다. iter = v.erase(iter); 

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 <stdio.h>
#include <vector>
using namespace std;
 
void main()
{
    vector<int> v;
 
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
 
    for (vector<int>::iterator iter = v.begin(); iter != v.end(); ++iter)
    {
        if ( *iter == 3 )
        {
            iter = v.erase(iter);
        }
    }
 
    for (vector<int>::iterator iter = v.begin(); iter != v.end(); ++iter)
    {
        printf("%d\n"*iter);
    }
    printf("size : %d\n", v.size());
}
cs

 

이터레이터(iterator)를 사용하지 않는 경우는 다음과 같이 구현합니다.

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 <stdio.h>
#include <vector>
using namespace std;
 
void main()
{
    vector<int> v;
 
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
 
    for (int i = 0; i < v.size(); i++)
    {
        if ( v[i] == 3 )
        {
            v.erase(v.begin()+i);
        }
    }
 
    for (vector<int>::iterator iter = v.begin(); iter != v.end(); ++iter)
    {
        printf("%d\n"*iter);
    }
    printf("size : %d\n", v.size());
}
cs

 

감사합니다.

반응형
반응형

안녕하세요.

오늘은 16진수 문자열을 10진수로 변경하는 방법에 대해 알아보도록 하겠습니다.

일단 간단하게 strtol함수를 이용할 수 있습니다.

stdlib.h헤더 파일만 추가하고 사용하면 됩니다.

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#include <stdlib.h>
 
void main()
{
    char chHex[] = "9B";
    unsigned int nResult = 0;
    
    nResult = strtol(chHex, NULL16);
 
    printf ( "%s => %d\n", chHex, nResult );
}
cs

 

직접 구현할 수도 있습니다.

보통 코딩문제에서도 많이 나오는 경우가 있는데, 다음과 같이 구현할 수 있습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <string.h>
 
void main()
{
    char chHex[] = "9b";
    unsigned int nResult = 0;
    
    for ( int i = 0; i <= strlen(chHex); i++ )
    {
        if ( chHex[i] >= 'A' && chHex[i] <= 'F' )                // chHex값이 'A'(65)~'F'(70) 일때
            nResult = nResult * 16 + chHex[i] - 'A' + 10;
        else if ( chHex[i] >= 'a' && chHex[i] <= 'f' )                // chHex값이 'a'(97)~'f'(102) 일때
            nResult = nResult * 16 + chHex[i] - 'a' + 10;
        else if ( chHex[i] >= '0' && chHex[i] <= '9' )            // chHex값이 '0'(48)~'9'(57) 일때
            nResult = nResult * 16 + chHex[i] - '0';
    }
 
    printf ( "%s => %d\n", chHex, nResult );
}
cs

코드 설명을 하자면, 자릿수에 따라 16을 곱하고 0~F(16)을 더합니다.

0~F값을 더하기 위해서는 문자열의 각각 문자에 대해 'A'~'F' 일 경우에는 'A'값을 빼고 10을 더해줘서 10~F(16) 값을 만들어주고, 'a'~'f' 일경우에는 'a'값을 빼고 10을 더해줘서 10~F(16) 값을 만들어주고, '0'~'9' 일경우에는 '0'값을 빼서 0~9 값을 만들어줍니다.

예를 들면 9b 같은 경우에는 일단 chHex[0]값이 '9'를 계산해서 nResult에 넣습니다.

nResult = 0(nResult) * 16 + 57('9') - 48('0') = 9

그리고 다음 chHex[1]값 'b'를 nResult에 더해줍니다.

nResult = 9(nResult) * 16 + 98('b') - 97('a') + 10 = 155

 

출력값은 다음과 같습니다.

9b => 155

반응형
반응형

안녕하세요.

특정 폴더의 파일리스트를 받아와야하는 경우가 있습니다.

검색이 수월하지 않는 것 같아서, 제가 구현한 내용을 정리하면서 올립니다.

테스트를 많이하지 않아서 오류나 버그가 있을 수 있으니, 참고 부탁드립니다.

그리고 컴파일러는(Visual Studio)는 관리자권한으로 실행해야합니다.

실행파일도 마찬가지로 관리자권한으로 실행해야 제대로 파일리스트를 얻을 수 있습니다.

이렇게 구현했습니다.

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
#include <Windows.h>
#include <string>
#include <stdio.h>
using namespace std;
 
FILE *fp;
 
void FindFile(wchar_t* path);
void main()
{
    // 파일리스트를 파일로 저장합니다.
    fp = _wfopen(L"filelist.txt", L"w+");
    // 특정경로지정
    wchar_t path[256= L"C:\\Patch\\";
 
    FindFile(path);
    fclose(fp);
    
}
void FindFile(wchar_t* path)
{
    WIN32_FIND_DATA fd;
 
    wchar_t path2[256];
    wsprintf(path2, L"%s%s", path, L"*.*" );
 
    HANDLE hFind = ::FindFirstFile(path2, &fd);
 
    if( hFind != INVALID_HANDLE_VALUE )
    {
        do
        {
            if(!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
            {
                // 콘솔창에서 출력
                //wprintf(L"%s\n", fd.cFileName);
                // 파일로 저장
                fwprintf(fp, L"%s\n", fd.cFileName);
            }
            else
            {
                if( fd.cFileName[0!= '.')
                {
 
                wchar_t path3[256];
                wsprintf(path3, L"%s%s\\", path, fd.cFileName );
                //재귀호출합니다.
                FindFile(path3);
                }
            }
        }while(::FindNextFile(hFind,&fd));
        ::FindClose(hFind);
    }
}
cs

C드라이브의 Patch폴더에 있는 모든 파일들을 얻어오는 코드입니다.

재귀호출을 이용하여 하위 폴더에 있는 파일까지 얻어올 수 있습니다.

콘솔로 띄우면 파일이 많아질 경우 확인이 어렵기 때문에 파일로 저장되도록 처리했습니다.

프로젝트 폴더에서 확인하면 filelist.txt파일로 확인할 수 있습니다.

만약 경로까지 파일에 저장하려면,

38줄의 fwprintf(fp, L"%s\n", fd.cFileName); 부분을

fwprintf(fp, L"%s%s\n", path, fd.cFileName);  이렇게 변경해주면,

경로가 같이 저장됩니다.

 

wchar_t 대신 char형으로 사용해야하는 경우는 다음과 같이 구현할 수 있습니다.

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
#include <Windows.h>
#include <string>
#include <stdio.h>
#include <io.h>
#include <conio.h>
using namespace std;
 
FILE *fp;
 
void FindFile(char* path);
void main()
{
    // 파일리스트를 파일로 저장합니다.
    fp = fopen("filelist.txt""wb");
    // 특정경로지정
    char path[256= "C:\\Patch\\";
 
    FindFile(path);
    fclose(fp);
    
}
void FindFile(char* path)
{
    _finddata_t fd;
 
    char path2[256];
    sprintf(path2, "%s%s", path, "*.*" );
 
    long hFind = _findfirst(path2, &fd);
 
    if( hFind != -1 )
    {
        do
        {
            if(!(fd.attrib & FILE_ATTRIBUTE_DIRECTORY))
            {
                // 콘솔창에서 출력
                //wprintf(L"%s\n", fd.cFileName);
                // 파일로 저장
                fprintf(fp, "%s\n", fd.name);
            }
            else
            {
                if( fd.name[0!= '.')
                {
 
                char path3[256];
                sprintf(path3, "%s%s\\", path, fd.name );
                //재귀호출합니다.
                FindFile(path3);
                }
            }
        }while(_findnext(hFind,&fd) != -1);
        _findclose(hFind);
    }
}
cs
반응형
반응형

안녕하세요.

 

오늘은 for문을 이용해서 다양한 형태로 별찍기를 해보겠습니다.

 

for문을 이해하는데 도움이 될 것 같아서 올려봅니다.

 

5개씩 출력되게 별찍기

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
void main()
{
    int i = 0, j = 0;
 
    for ( i = 0; i < 5; i++ )
    {
        for ( j = 0; j < 5; j++ )
            printf("*");
        printf("\n");
    }
}
cs

 

별이 순차적으로 커지게 별찍기

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
void main()
{
    int i = 0, j = 0;
 
    for ( i = 0; i < 5; i++ )
    {
        for ( j = 0; j <= i; j++ )
            printf("*");
        printf("\n");
    }
}
cs

 

순차적으로 작아지게 별찍기

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
void main()
{
    int i = 0, j = 0;
 
    for ( i = 0; i < 5; i++ )
    {
        for ( j = 0; j < 5-i; j++ )
            printf("*");
        printf("\n");
    }
}
cs

 

공백추가해서 별찍기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
void main()
{
    int i = 0, j = 0, k = 0;
 
    for ( i = 0; i < 5; i++ )
    {
        for ( k = 0; k < i; k++ )
        {
            printf(" ");
        }
        for ( j = 0; j < 5-i; j++ )
            printf("*");
        printf("\n");
    }
}
cs

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
void main()
{
    int i = 0, j = 0, k = 0;
 
    for (i = 0; i < 5; i++)
    {
        for (k = 1; k < 5-i; k++)
        {
            printf(" ");
        }
        for (j = 0; j < i+1; j++)
            printf("*");
        printf("\n");
    }
}
 
cs

 

역삼각형으로 별찍기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
void main()
{
    int i = 0, j = 0, k = 0;
 
    for ( i = 0; i < 5; i+=2 )
    {
        for ( k = 0; k < i; k+=2 )
        {
            printf(" ");
        }
        for ( j = 0; j < 5-i; j++ )
            printf("*");
        printf("\n");
    }
}
 
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
#include <stdio.h>
void main()
{
    int i = 0, j = 0, k = 0;
 
    for ( i = 0; i < 5; i+=2 )
    {
        for ( k = 0; k < i; k+=2 )
        {
            printf(" ");
        }
        for ( j = 0; j < 5-i; j++ )
            printf("*");
        printf("\n");
    }
 
    for ( i = 3; i > 0; i-=2 )
    {
        for ( k = 1; k < i; k+=2 )
        {
            printf(" ");
        }
        for ( j = 0; j <= 5-i; j++ )
            printf("*");
        printf("\n");
    }
}
 
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
#include <stdio.h>
void main()
{
    int i = 0, j = 0, k = 0;
    int nNum = 0;
 
    printf("size(odd number:1,3,5,7..) : ");
    scanf("%d"&nNum);
 
    if( nNum % 2 == 0 )
    {
        printf("error : even number\n");
        return;
    }
 
    for ( i = 0; i < nNum; i+=2 )
    {
        for ( k = 0; k < i; k+=2 )
        {
            printf(" ");
        }
        for ( j = 0; j < nNum-i; j++ )
            printf("*");
        printf("\n");
    }
 
    for ( i = nNum-2; i > 0; i-=2 )
    {
        for ( k = 1; k < i; k+=2 )
        {
            printf(" ");
        }
        for ( j = 0; j <= nNum-i; j++ )
            printf("*");
        printf("\n");
    }
}
 
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
#include <stdio.h>
void main()
{
    int i = 0, j = 0, k = 0, l = 0, m = 0;
 
    for (i = 0; i < 5; i ++)
    {
        for (j = 0; j <= i; j ++)
             printf("*");
        for (k = 1; k < 5 - i; k++)
            printf(" ");
        for (l = 1; l < 5 - i; l++)
            printf(" ");
        for (m = 0; m <= i; m++)
            printf("*");
        printf("\n");
    }
 
    for (i = 1; i < 5; i++)
    {
        for (j = 0; j < 5 - i; j++)
            printf("*");
        for (k = 1; k <= i; k++)
            printf(" ");
        for (l = 1; l <= i; l++)
            printf(" ");
        for (m = 0; m < 5 - i; m++)
            printf("*");
 
        printf("\n");
    }
}
 
cs
반응형
반응형

안녕하세요.

배열처럼 사용할 변수를 미리 넉넉하게 할당해두고, 사용할 수도 있지만, 

메모리를 얼마나 사용할지 모르는 상황에 있을 때, 미리 너무 많이 선언에 놓으면 메모리 낭비가 일어날 수 도 있습니다.

이럴 때 동적으로 메모리를 할당하여 사용할 수 도 있습니다.

malloc

함수 원형
void* malloc(size_t _Size);

헤더 파일
stdlib.h

리턴값
void* 형은 어떤 타입으로도 변화되므로, 포인터 값만 가진 변수정도로 이해하면 좋을 것 같습니다.
리턴 받은 포인터로 필요한 타입( 예:pCh = (char*)malloc(sizeof(char)*5); )으로 캐스팅한 후 사용하면 됩니다.


설명
필요한 크기를 동적으로 할당하여 사용합니다.

데이터 크기에 맞춰서 할당해줘야 하므로 
"(데이터타입*)malloc(sizeof(데이터타입)*할당크기);"형식으로 할당합니다.

할당 메모리는 반드시 free함수를 통해 메모리 해제를 해야합니다.

 

free


함수 원형
void malloc(void* _Block);

헤더 파일
stdlib.h

리턴값
리턴값은 없습니다.

설명
malloc함수로 동적한 메모리를 해제할 떄 사용합니다.

 

예제

1. malloc과 free 사용 예제

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <stdlib.h>
 
void main()
{
    int* pPoint;
    pPoint = (int*)malloc(sizeof(int)*5);
 
    pPoint[0= 25;
    pPoint[1= 45;
    pPoint[2= 50;
    pPoint[3= 70;
    pPoint[4= 99;
    
    int i = 0;
    for ( i = 0; i < 5; i++ )
        printf("pPoint[%d] : %d\n", i, pPoint[i]);
 
    free(pPoint);
}
 
cs

결과값

설명

malloc함수를 이용해 int형으로 5개를 할당하였습니다.

배열과 같은 형식을 대괄호로 접근 가능합니다.

free함수를 통해 할당해제를 해야합니다.

 

2. 할당할 사이즈를 입력받아 동적할당하는 예제

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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
 
void main()
{
    int* pPoint;
 
    int nCount = 0;
 
    printf("malloc size ?? ");
    scanf("%d"&nCount);
 
    pPoint = (int*)malloc(sizeof(int* nCount);
 
    int i = 0;
    for (i = 0; i < nCount; i++)
    {
        printf("input pPoint[%d] : ", i);
        scanf("%d"&pPoint[i]);
    }
 
    for (i = 0; i < nCount; i++)
        printf("Output pPoint[%d] : %d\n", i, pPoint[i]);
 
    free(pPoint);
}
 
cs

결과값

설명

scanf함수를 통해 동적할당 개수를 입력 받은 후 개수 만큼 입력 받은 후 출력을 해줍니다.

반응형
반응형

안녕하세요.

C언어에서 특정 문자열를 검색하는 함수인 strstr에 대해 알아보겠습니다.

 

strstr


함수 원형
char* strstr(const char *_Str, const char *_SubStr);

헤더 파일
string.h

리턴값
_SubStr문자열과 같은 값을 가진 _Str문자열의 포인트값을 리턴해줍니다.
_Str에 _SubStr와 동일한 문자열이 없다면, NULL을 리턴합니다.

설명
문자열의 첫번째 문자부터 마지막 문자까지 검색을 해서 같은 문자열을 찾은 후 처음 찾은 포인터를 리턴합니다.
만약에 찾을 대상 문자열에 같은 값을 가진 문자열이 여러개 있어도 처음 찾은 포인터만 리턴하게 됩니다.


예제

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <string.h>
 
void main()
{
    char arrString[20= "Hello World";
    
    char* pCh1 = strstr(arrString, "llo");
    char* pCh2 = strstr(arrString, "rle");
 
    printf("strstr(arrString, ""llo"") : %s\n", pCh1);
    printf("strstr(arrString, ""rle"") : %s\n", pCh2);
}
 
cs

결과값

문자열 배열 arrString("Hello World")에서

8번째 줄 코드(char* pCh1 = strstr(arrString, "llo");)에서는 "llo"문자열을

strstr함수를 통해 찾는데, "Hello World"의 세번째 문자부터 다섯번째 문자가

동일한 문자열이 된다.

그러므로 리턴값은 세번째 문자 포인터값을 가지게 되므로 "llo World"가 출력이 됩니다.

 

9줄 코드(char* pCh2 = strstr(arrString, "rle");)에서는

"rle"문자열을 "Hello World"문자열에서 찾는데, 비슷하게 맞는 문자열은 있지만, 

정확하 동일한 문자열을 찾을 수 없습니다. 

그러므로 null이 리턴되게 됩니다.

 

반응형
반응형

안녕하세요.

오늘은 C언어에서 문자를 검색하는 함수인 strchr 함수에 대해 알아보도록 하겠습니다.

strchr

함수 원형
char* strchr(const char *_Str, int _Val);

헤더 파일
string.h

리턴값
_Val와 같은 값을 가진 _Str문자열의 포인트값을 리턴해줍니다.
_Str에 _Val와 같은 값이 없다면 NULL을 리턴합니다.


설명
문자열의 첫번째 문자부터 마지막 문자까지 검색을 해서 처음 찾은 포인터를 리턴합니다.
만약에 찾을 대상 문자열에 같은 값을 가진 문자가 여러개 있어도 처음 찾은 포인터만 리턴하게 됩니다.


예제

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#include <string.h>
 
void main()
{
    char arrString[20= "Hello World";
    char *pCh1 = strchr(arrString, 'o');
    char *pCh2 = strchr(arrString, 'a');
 
    printf("strchr(arrString, 'W') : %s\n", pCh1);
    printf("strchr(arrString, 'a') : %s\n", pCh2);
}
 
cs

코드분석

7번째 줄에서(char *pCh1 = strchr(arrString, 'o');)는 arrString[20] 문자열 "Hello world"값 중 'o'를 찾게되면 "Hello World"의 다섯번째 문자를 포인터를 리턴하게 됩니다.

그로인해서 pCh1은 다섯번째 문자의 포인터값을 받아서 출력을 하게되면 다섯번째 문자부터 '\0'이전 값까지 출력이 됩니다.

 

8번째 줄에서(char *pCh2 = strchr(arrString, 'a');)는 arrString[20]값중 'a'를 가진 값이 없기 때문에 NULL값을 리턴하게 됩니다.

 

간단한 응용

간단하게 문자열에 특정 문자가 몇개가 있는지 확인하는 프로그램을 만들어보겠습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <string.h>
 
void main()
{
    char arrString[20= "Hello World";
    int nCount = 0;
    char* pCh = arrString;
 
    while (pCh)
    {
        pCh = strchr(pCh, 'o');
        if (pCh)
        {
            pCh++;
            nCount++;
        }
    }
 
    printf("find count : %d", nCount);
}
 
cs

코드분석

8번째 줄(char* pCh = arrString;)에서 arrString의 시작 주소를 포인터인 pCh로 저장합니다.

12번째 줄(pCh = strchr(pCh, 'o');)에서 strchr함수를 이용해서 'o'문자 찾습니다.

찾은 후 그 위치를 pCh에 저장합니다.

그리고 찾은 위치의 포인터에 1을 더해서 다음 포인터를 저장합니다.

찾았기 때문에 nCount를 1증가시킵니다.

 while문에 pCh값이 null이 아니기 때문에 반복문으로 다시 한번 더 strchr함수를 이용해서 'o'를 찾습니다.

찾은 후 다시 pCh에 값을 저장합니다.

pCh와 nCount를 1씩 증가시킨 후 다시 while문으로 반복하여 'o'문자 찾습니다.

이제 더이상 'o'문자가 없기 때문에 strchr함수에서 null을 리턴하게 되면서 while문을 빠져나오게 됩니다.

반응형
반응형

안녕하세요.

오늘은 C언어에서 문자열의 길이를 알아내는 함수인 strlen 함수에 대해 알아보도록 하겠습니다.

 

strlen

함수 원형
size_t strcat(const char *_Str);

헤더 파일
string.h

리턴값
_Str문자열의 길이가 리턴됩니다.

설명
문자열의 길이가 리턴됩니다.
문자열의 크기로 혼동될 수 있는데, 길이 입니다.
문자열의 데이터 중 '\0'값 이전값까지 문자열 길이를 리턴합니다.

예제

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
#include <string.h>
 
void main()
{
    char arrString1[10= "Hello";
    char arrString2[10= "Worl\0d!!";
    
    printf("arrString1 len : %d\n", strlen(arrString1));
    printf("arrString2 len : %d\n", strlen(arrString2));
}
 
cs

 

 

 

strlen는 해당 문자열의 크기가 아니라 길이를 리턴합니다.

arrString1[10]은 크기가 10이지만 길이는 "Hello"이렇게 5문자가 됩니다.

간혹 혼란이 많이 생기는 부분입니다.

참고로 문자열 배열의 크기를 알아내는 함수는 sizeof()입니다.

 

arrString2 문자열의 경우에는 "worl\0d!!\0"을 데이터로 갖고 있습니다.

strlen함수를 이용하여 길이를 확인하면 4가 리턴됩니다.

함수자체내에서 문자를 하나씩 '\0'(NULL)값을 체크하면서 카운트를 한 후

'\0'일 경우에는 해당 카운트를 리턴해주는 것으로 보입니다.

 

strlen 응용

 strcat함수와 같이 응용하는 코드를 한번 만들어보겠습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#define _CRT_SECURE_NO_WARNINGS        // vs2017 이후 버전은 strcat함수 실행시 보안 에러발생으로 인해 추가합니다.
#include <stdio.h>
#include <string.h>
 
void main()
{
    char arrString1[20= "Hello";
    char arrString2[20= "";
 
    scanf("%s", arrString2);
    while (getchar() != '\n');
 
    int nLength = strlen(arrString1) + strlen(arrString2) ;
 
    if (sizeof(arrString1) > nLength)
    {
        strcat(arrString1, arrString2);
        printf("arrString1 : %s\n", arrString1);
    }
    else
    {
        printf("Error over size \n");
    }
}
cs

"12345678901234" 입력 시 다음과 같이 출력이 됩니다.

arrString1을 크기가 20으로 되어있어서, "Hello"(5)와 "12345678901234"(14)를 합치더라도 크기가 넘치지 않습니다.

다음 "123456789012345" 입력 시에는 다음과 같이 출력되게 됩니다.

"Hello"(5)와 "123456789012345"(15)이므로 '\0'까지 포함하게되면 크기가 넘치므로,

else문의 "Error over size"를 호출하게 됩니다.

반응형
반응형

안녕하세요.

오늘은 C언어에서 문자열을 붙이는 함수인 strcat와 strncat 함수에 대해 알아보도록 하겠습니다.

strcat

함수 원형
char* strcat(char *_Destination, const char *_Source);

헤더 파일
string.h

리턴값
_Destination의 포인터값이 리턴됩니다.

설명
특정 문자열을 붙입니다.
첫번째 매개변수인 _Destination문자열에 두번째 매개변수인 _Source문자열을 넣습니다.
두 문자열을 합친 크기가 _Destination의 크기보다 작아야합니다.

예제

1
2
3
4
5
6
7
8
9
10
11
12
#define _CRT_SECURE_NO_WARNINGS        // vs2017 이후 버전은 strcat함수 실행시 보안 에러발생으로 인해 추가합니다.
#include <stdio.h>
#include <string.h>
void main()
{
    char arrString1[20= "Hello";
    char arrString2[20= "World!!";
 
    strcat(arrString1, arrString2);
 
    printf("%s\n", arrString1);
}
 
cs

arrString1의 \0(NULL)값 위치에 arrString2가 붙게됩니다.

 

strncat

함수 원형
int strncmp( char *_Destination, const char *_Source, size_t count);

헤더 파일
string.h

리턴값
_Destination의 포인터값이 리턴됩니다.

설명
특정 문자열을 특정 크기만큼 붙입니다.
첫번째 매개변수인 _Destination문자열에 두번째 매개변수인 _Source문자열 count만큼 붙입니다.
count는 _Destination의 크기보다 같거나 작아야합니다.

예제

1
2
3
4
5
6
7
8
9
10
11
12
#define _CRT_SECURE_NO_WARNINGS        // vs2017 이후 버전은 strncat함수 실행시 보안 에러발생으로 인해 추가합니다.
#include <stdio.h>
#include <string.h>
 
void main()
{
    char arrString1[20= "Hello";
    char arrString2[20= "World!!";
 
    strncat(arrString1, arrString2, 5);
    printf("%s\n", arrString1);
}
 
cs

arrString1의 \0(NULL)값 위치에 arrString2의 문자를 5개(world)까지 붙여 넣습니다.

그리고 끝에는 \0(NULL)값이 붙습니다.

 

반응형
반응형

안녕하세요.

오늘은 문자열을 숫자로 변경하는 함수에 대해 알아보도록 하겠습니다.

atoi, atol

함수 원형
int atoi(const char* _String);
int atol(const char* _String);

헤더 파일
stdlib.h

설명
문자열(char*)을 정수(int)로 변환하기 위해 사용됩니다.

리턴값
_String 문자열을 정수로 리턴됩니다.

정수로 변환될 수 없는 문자인 경우에는 0이 리턴됩니다. ex) "AA"
정수 + 정수로 변환될 수 없는 문자일 경우 정수로 리턴됩니다.(ex) "78a" -> 78, "78.2"->78
_String값이 정수최대값 보다 크면, INT_MAX값(2147483647)을 리턴해주고 정수최소(-2147483648)값보다 작으면, INT_MIN값을 리턴합니다.

 

예제

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <stdlib.h>>
 
void main()
{
    int nReturn1 = atoi("78");
    int nReturn2 = atoi("78a");
    int nReturn3 = atoi("a78");
    int nReturn4 = atoi("AA");
    int nReturn5 = atoi("123456789012345678");
    int nReturn6 = atoi("-123456789012345678");
 
    printf("atoi(""78"") return value : %d\n", nReturn1);
    printf("atoi(""78a"") return value : %d\n", nReturn2);
    printf("atoi(""a78"") return value : %d\n", nReturn3);
    printf("atoi(""AA"") return value : %d\n", nReturn4);
    printf("atoi(""123456789012345678"") return value : %d\n", nReturn5);
    printf("atoi(""-123456789012345678"") return value : %d\n", nReturn6);
}
 
cs

결과값

 

atof

함수 원형
double atof(const char* _String);

헤더 파일
stdlib.h

설명
문자열(char*)을 실수(double)로 변환하기 위해 사용됩니다.

리턴값
_String 문자열을 실수로 리턴됩니다.

실수로 변환될 수 없는 문자인 경우에는 0.0이 리턴됩니다. ex) "AA"
실수 + 실수로 변환될 수 없는 문자일 경우 정수로 리턴됩니다. ex)"78.5a"
부동소수점e,E로 표현 가능합니다. ex) "1232323E20"

예제

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <stdlib.h>>
 
void main()
{
    double dbReturn1 = atof("78.5");
    double dbReturn2 = atof("78.5a");
    double dbReturn3 = atof("a78");
    double dbReturn4 = atof("AA");
    double dbReturn5 = atof("1232323E20");
 
 
    printf("atoi(""78"") return value : %lf\n", dbReturn1);
    printf("atoi(""78a"") return value : %lf\n", dbReturn2);
    printf("atoi(""a78"") return value : %lf\n", dbReturn3);
    printf("atoi(""AA"") return value : %lf\n", dbReturn4);
    printf("atoi(""123456789012345678"") return value : %E\n", dbReturn5);
}
 
cs

 

결과값

반응형

+ Recent posts