KDJ

+=, -=, *=, /=, %=, ^=, |=등이 있으며 이들을 복합대입연산자 or OP= 연산자라고 한다.

================== [ 예제 1 ] ===========================

a = 0;

a += 10;

trace(a);

[결과: output창]

10

========================================================

a += 10; 은 a 변수의 값을 10으로 더하고, 더한 결과값을 a 변수에 다시 대입하라는 말입니다.

a = a + 10; 과 같은 의미입니다.

(주의) + 와 = 사이를 띄어쓰면 구문에러가 발생합니다.

================== [ 예제 2 ] ===========================

a = 10;

a -= 10;

trace(a);

[결과: output창]

0

========================================================

a -= 10; 은 a 변수의 값에서 10을 빼고, 뺀 결과값을 a 변수에 다시 대입하라는 말입니다.

a = a - 10; 과 같은 의미입니다.

================== [ 예제 3 ] ===========================

a = 10;

a *= 10;

trace(a);

[결과: output창]

100

========================================================

a *=10; 은 a 변수의 값을 10으로 곱하고, 곱해진 결과 값을 다시 a 변수에 대입하라는 말입니다.

a = a * 10; 과 같은 의미입니다.

================== [ 예제 4 ] ===========================

a = 10;

a /= 10;

trace(a);

[결과: output창]

1

========================================================

a /= 10; 은 a 변수의 값을 10으로 나누고, 나눠진 결과값을 다시 a 변수에 대입하라는 말입니다.

a = a / 10; 과 같은 의미입니다.

================== [ 예제 5 ] ===========================

a = 10;

a %= 3;

trace(a);

[결과: output창]

1

========================================================

a %= 3; 은 a 변수의 값을 3으로 나눠서 나머지를 구하고, 그 나머지 값을 a 변수에 대입하라는 말입니다.

a = a % 3; 과 같은 의미입니다.

================== [ 예제 6 ] ===========================

a = 0;

a ^= 1;

trace(a);

[결과: output창]

1

========================================================

a ^= 1; 은 a 변수에 ^(Xor)연산을 하고, 결과값을 다시 a 변수에 대입하라는 말입니다.

a = a ^ 1; 과 같은 의미입니다.

예제 6에서 사용된 ^(Xor)연산자는 현재 a 변수의 값이 0이면 1로 바꾸고, 1이면 0으로 다시 바꾸는 연산을 합니다.

(참고) ^ 연산자는 논리연산자 파트에서 자세히 설명드립니다.

더하기.

===============================

a = 0;

b = 10;

a++;

b--;

trace(a);

trace(b);

[결과 :  output  창]

1

9

===============================

a++  은 a = a + 1과 같은 의미이며 a+=1;과 같은 의미이다.

b-- 는 b = b - 1과 같은 의미이며 b-=1; 과 같은 의미이다.

원본 위치 <http://yawoong.com/board/view.php?id=tutorial_choi&no=39>

 


========================================================

aaa  |= 1; 현재 가지고 있는 값에 값을 더한다.

#include "stdafx.h"

#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])

{

int aaa = 0;

aaa |= 1;                cout << "aaa: " << aaa << endl;

aaa |= 2;                cout << "aaa: " << aaa << endl;

aaa |= 4;                cout << "aaa: " << aaa << endl;

aaa |= 8;                cout << "aaa: " << aaa << endl;
aaa |= 16;              cout << "aaa: " << aaa << endl;

aaa |= 32;              cout << "aaa: " << aaa << endl;

aaa |= 64;              cout << "aaa: " << aaa << endl;

aaa |= 128;            cout << "aaa: " << aaa << endl;

return 0;

}

time_t timer;

struct tm *t;

timer = time(NULL); // 현재 시각을 초 단위로 얻기

t = localtime(&timer); // 초 단위의 시간을 분리하여 구조체에 넣기

tm struct (time.h)

struct tm {

  int tm_sec;   /* Seconds */

  int tm_min;   /* Minutes */

  int tm_hour;  /* Hour (0--23) */

  int tm_mday;  /* Day of month (1--31) */

  int tm_mon;   /* Month (0--11) */

  int tm_year;  /* Year (calendar year minus 1900) */

  int tm_wday;  /* Weekday (0--6; Sunday = 0) */

  int tm_yday;  /* Day of year (0--365) */

  int tm_isdst; /* 0 if daylight savings time is not in effect) */

};

출처 : http://dorio.tistory.com/entry/CC%ED%98%84%EC%9E%AC%EC%8B%9C%EA%B0%84-%EC%96%BB%EA%B8%B0

원본 위치 <http://www.iamcorean.net/98>

원본 위치 <http://ttongfly.net/zbxe/?document_srl=45283>

코드 실행 시간 측정 방법 정리

- 한양대 바라미 6기 이흔진    

 이번에 알아보는 것은 Visual C++에서 시간을 측정하는 방법입니다. Visual C++에서 시간을 측정하는 방법은 여러 가지가 있는데 . ANSI C의 함수를 이용하는 방법부터 윈도우 API 함수를 이용하는 방법까지 다양합니다. 그리고, 각각의 방법을 사용하기 위해서 함수에 따라 적절히 헤더를 Include 해줘야 하기도 합니다.

 다음은 DEVPIA와 MSDN 을 통해서 찾은 여러 가지 시간 측정하는 방법입니다. 여러 님들이 올리신 글들을 제가 한번 정리해 본 것이구요, 소스를 직접 테스트 해보기도 하고 수정을 하기도 했습니다. 그리고 각각의 방법들은 형태는 다르지만 모두 공통점이 있습니다. 바로 실행 시간을 측정하기 위해서 원하는 루틴의 시작점과 종료점에서 시간 측정과 관련하는 함수를 부른다는 겁니다. 그래서 그 루틴이 시작할 당시에 비해 CPU 클럭이 얼마나 지났는지를 따져서, 즉 그 시작점과 종료점의 클럭의 차이를 이용해서 실행 시간을 구합니다.

 간단한 설명은 여기서 마치고, 직접 한번 살펴보세요. 그리고, 직접 한 번 돌려보시길 바랍니다.

 눈으로만 읽어선 절대로 자기의 것이 될 수 없으니까요..^^;

순서..

1. clock() 함수 이용 실행시간 측정.

2. timeGetTime()함수 이용 실행시간 측정.

3. QueryPerformanceCounter()함수 이용 실행시간 측정.

             4. 매크로를 이용한 실행시간 측정. [밀리세컨트(ms)단위]

             5. Debugging 중에 @CLK를 이용한 실행시간 측정.

             6. 프로파일 기능을 이용한 각 함수들의 실행시간 알아보기.

]--------------------------------------------------------------------

1. clock() 함수 이용 실행시간 측정. [초(s)단위]

--------------------------------------------------------------------

어떤 작업을 수행하는데 걸리는 시간을 알고 싶은 경우는 흔하지만, 방법을 잘 몰라서 그냥 넘어가는 경우가 많습니다. 아래 소개된 방법이 가장 일반적인 방법이며 이보다 나은 방법은 아마 없다고 생각합니다. 그다지 어렵지 않으니 천천히 보세요.

컴퓨터에는 Clock Ticks라는 것이 있습니다. 그리고 운영체제에는 어떤 프로세스가 시작한지 얼마나 지났는지 알려주는 clock() 함수를 가지고 있구요. 이것을 이용하는 방법입니다.

clock_t current_tick = clock();

이 코드로 현재 프로세스가 실행한지 얼마나 지났는지를 Clock Tick단위로 알 수 있습니다. 시간을 알고 싶으시면 이 Clock Tick단위를 초단위로 변환해주면 되죠.

double current_sec = current_tick / CLOCKS_PER_SEC;

이 코드가 Tick 단위를 초단위로 환산해주는 코드입니다.

CLOCKS_PER_SEC은 time.h화일에 정의되어 있는 상수입니다.

간단히 예제를 만들어 보면,

#include "stdio.h"

#include "time.h"

void main()

{

clock_t before;

double result;

before = clock();

for ( int i = 0; i <32765; i++ ) printf("%dn", i );

result = (double)(clock() - before) / CLOCKS_PER_SEC;

printf("걸린시간은 %5.2f 입니다.n", result); 

} 

 간단하게 C 스타일로 예를 들었지만, MFC환경에서도 잘 돌아갑니다.

--김현승(Puzzle)님이 올려주신 글입니다.

 --------------------------------------------------------------------

2. timeGetTime() 함수 이용. [밀리세컨드(ms)단위]

--------------------------------------------------------------------

 제가 즐겨 쓰는 방법은 multimedia timer를 사용하는 겁니다.

함수는 timeGetTime() 이구요, 밀리세컨드(ms)단위로 측정가능합니다.

방법은 아주 간단합니다.

DWORD dwStartTime = timeGetTime();

// 처리부분

...

// 처리부분 종료

DWORD dwEndTime = timeGetTime();

printf("%d ms", dwEndTime-dwStartTime);

 필요한 부분에 추가하시고 쓰면 됩니다.

단, 사용하기 위해서는 사용하는 파일에 Mmsystem.h 를 Include 해주고,winmm.lib 를 Project=>Setting(ALT+F7) 메뉴의 LINK 텝에서 Object/library modules: 에 추가를 해주어야 합니다..

--DEVPIA에 올리신 김영훈(zenk)님의 글입니다.      

 -----------------------------------------------------------------------------

3. QueryPerformanceCounter() 함수 이용 [ ms단위]

 -----------------------------------------------------------------------------

 다음은 QueryPerformanceFrequency() 와 QueryPerformanceCounter()를 이용한 방법입니다. 밀리 세컨드 단위로 측정 가능하구요, #include <Windows.h> 를 해주어야 합니다. 한가지 단점은 시스템에 따라 얼마나 작은 시간을 잴 수 있는지가 제한된다는 것입니다. 하지만 CPU의 속도에 의해 결정되는 것은 아니므로 조금 느린 시스템이라고 해서 걱정하실 필요는 없습니다. API 의 도움말을 보면 시스템에 따라 CPU 클럭의 레벨까지도 체크가 가능하다는군요. 사용하는 API 함수는 High Performance Timer Functions라고 불리는 QueryPerformanceFrequency() 와 QueryPerformanceCounter() 라는 두 개의 함수입니다.

앞의 놈은 자기 시스템이 최대 어느 정도까지의 timer resolution을 지원하는지를 판별하는데 쓰이구요, 뒤엣 놈은 현재의 카운터를 알아내는 데 사용됩니다. 예를 들어 앞의 함수를 콜한 후 넘겨준 파라미터 값이 10000 으로 되어 있다면 그 시스템은 10000분의 1초 (=> 1/10000) 즉 0.1밀리초까지 판별할 수 있습니다.  

그리고 어떤 작업을 수행하기전에 QueryPerformanceCounter를 한번실행하고 수행후 다시 콜함으로써 각각 얻어진 카운터값의 차이를 구함으로써 수행시간을 판단할 수 있습니다

//멤버변수나 로컬변수로 변수지정

LARGE_INTEGER Frequency;

LARGE_INTEGER BeginTime;

LARGE_INTEGER Endtime;

//프로그램이나 클래스 시작부분에

QueryPerformanceFrequency( &Frequency );

//사용하고자 하는 부분에 다음 코딩

QueryPerformanceCounter( &BeginTime );

처리함수();

QueryPerformanceCounter( &endtime );

int64 elapsed = Endtime.QuadPart- BeginTime.QuadPart;

double duringtime = (double)elapsed / (double)Frequency.QuadPart;

//다음은 변수를 달리 했을 때의 사용법입니다.

__int64 Frequency;

__int64 BeginTime;

__int64 Endtime;

//프로그램이나 클래스 시작부분에

QueryPerformanceFrequency((LARGE_INTEGER *) &Frequency );

//사용하고자 하는 부분에 다음 코딩

QueryPerformanceCounter((LARGE_INTEGER *) &BeginTime );

처리함수();

QueryPerformanceCounter((LARGE_INTEGER *) &endtime );

int64 elapsed = Endtime - BeginTime;

double duringtime = (double)elapsed / (double)Frequency.QuadPart;

 --DEVPIA에 올리신 오희백(ohpwin)님의 글을 수정한 것입니다.      

 -------------------------------------------------------------------------

4. 매크로를 이용한 실행시간 측정. [밀리세컨드(ms)단위]

 -------------------------------------------------------------------------

//다음 두줄을 복사해서 쓰시면 됩니다.

// 이 매크로는 Win32 함수를 이용하여 nano second까지 측정할 수 있습니다.

#define CHECK_TIME_START __int64 freq, start, end; if (QueryPerformanceFrequency((_LARGE_INTEGER*)&freq)) {QueryPerformanceCounter((_LARGE_INTEGER*)&start);

 // a는 float type milli second이고 b가 FALSE일때는 에러입니다

#define CHECK_TIME_END(a,b) QueryPerformanceCounter((_LARGE_INTEGER*)&end); a=(float)((double)(end - start)/freq*1000); b=TRUE; } else b=FALSE;

 위의 내용을 조금 바꾸면 나노까지 측정 가능하죠.. 우선은 mili가지 측정됩니다.

그리고 windows.h포함해야 합니다. 매크로로 만들어 놔서 조금은 편하답니다.

이용하는 구체적인 방법은 다음 코드를 참조하세요.

#include <windows.h>

#include <stdio.h>

#define CHECK_TIME_START __int64 freq, start, end; if (QueryPerformanceFrequency((_LARGE_INTEGER*)&freq)) {QueryPerformanceCounter((_LARGE_INTEGER*)&start);  

// a는 float type milli second이고 b가 FALSE일때는 에러입니다

#define CHECK_TIME_END(a,b) QueryPerformanceCounter((_LARGE_INTEGER*)&end); a=(float)((double)(end - start)/freq*1000); b=TRUE; } else b=FALSE;

void main()

{

float Time;

BOOL err;

CHECK_TIME_START;

//....측정하고자 하는 구간..예를들어..printf()같은거

printf("나는 바보 입니다.");

CHECK_TIME_END(Time, err);

if(err) printf("printf() 걸린 시간은.. %8.6f미리세컨입니다.",Time);

}

 --DEVPIA에 올리신 김태연(MonoEye)님의 글을 수정한 것입니다.      

--------------------------------------------------------------------

5. Debugging 중에 @CLK를 이용한 실행시간 측정.

--------------------------------------------------------------------

 다음은 실행시간을 측정하는 간단한 Debugging Technic 입니다.

 프로그램을 하다 보면, 특정한 루틴이 과연 얼마나 많은 시간을 차지하는지 알고 싶은 경우가 있습니다. 물론, 많은 경우는 아니지만, 특정한 알고리즘을 만든 경우.. 다른 알고리즘과 처리 시간을 비교해 보고 싶은 경우가 있죠. 이럴 때 시스템 시간을 구해서 비교하는 방법들을 많이 사용하는데요,

 실제로는 그렇게 할 필요가 없죠.. Watch Window 에서 앞에 골뱅이(@) 붙여서 사용하는 레지스트리 값들있죠? 골뱅이 시리즈 중에 하나를 사용하시면 된답니다.

 @CLK

 (CLK == Clock)

위에 있는 @CLK는 말이죠. 현재 프로세스의 Clocking을 나타내줍니다. 그런데 위의 값을 사용자가 임의로 초기화 할 수 있기 때문에, 유용하게 사용할 수가 있는 것이랍니다.

 자.. 예를 들어서..

A 라는 루틴이 있는데, A 가 과연 얼마나 시간이 걸리는지 알고 싶습니다.

그러면 어떻게 @CLK를 사용해야 할까요?

우선 A 에 들어가기 전에 Break Pointer를 걸어두고, @CLK를 초기화 하시면 됩니다.

그리고 A 가 끝나는 부분에 다시 Break Pointer를 걸어두시면 바뀐 @CLK 값을 확인해 보실 수 있겠죠. @CLK 값은 밀리세컨드 단위니까. @CLK/1000,d 라고 하시면 초 단위로 보실 수 있습니다.

그럼 간단한 예제를 통해서 실제 사용방법을 살펴 보고 , 마무리 하겠습니다.

#include "stdafx.h"

int main(int argc, char* argv[])

{

// Break Pointer 설치하는 방법

// Alt+F9 를 눌러서 Break at 란에.. 아래와 같이..

// {,"ClockTest.cpp",} .23

// {,"ClockTest.cpp",} .39

// 입력합니다.

// 첫번째 Break pointer

// 이 부분에서 'User Breakpointer' 가 call 되면

// Watch Window 에 아래의 값을 넣습니다.

// ----

// @CLK

// @CLK=0

// ----

// 위에서 @CLK 는 시스템 Clocking 을 사용하겠다는 말이고,

// @CLK=0 는 스스템 Clocking 을 0으로 초기화 하겠다는 말입니다.

// 이제 이 상태에서 다시 Go 버튼을 눌러서 프로그램을 실행하면..

// 두번째 User Breakpointer 가 call 됩니다.

int i, j, k;

for (i = 0 ; i <1000 ; i++)

for (j = 0 ; j <1000 ; j++)

for (k = 0 ; k <1000 ; k++)

;

// 두번째 Break Pointer

// 이 부분에서 'User Breakpointer' 가 call 되면 Watch Window 에 있는

// 첫번째 @CLK 값이 초과된 시간을 보여줍니다..

// 물론 이 값에는 Debugging 때문에 여러가지 추가 작업들이

// 행해져서 정확한 프로그램 실행시간이 아니지만, 여러가지

//작업을 상대적으로 비교할 수는 있겠죠..

return 0;

}

--DEVPIA에 올리신 서우석(seaousak)님의 글입니다.

 ------------------------------------------------------------------------------

6. 프로파일 기능을 이용한 각 함수들의 실행시간 알아보기

 ------------------------------------------------------------------------------

 프로그램을 짜면서 각 함수가 어느 정도의 시간이 걸리는 지 알아보려는 노력들을 많이 합니다. 실제 실행시간일 수도 있고 전체 프로그램에서 어느 정도의 비율로 작용하는 지 알고싶을 때도 있구요...

 이 때 프로그램의 각 함수별로 실행시간과 전체에서의 비율, 호출 횟수등을 알 수 있는 방법이 있습니다. 이것은 Debug모드에서만 가능합니다… 

1.  Project – Settings 메뉴를 선택한다

2. Link 탭으로 간다. ‘Enable profiling’을 선택한다.

3. 그러고나면 Build 메뉴의 ‘Profile…’ 메뉴가 활성화가 된다.

4. 반드시 Rebuild 시킨후에 ‘Profile…’ 메뉴를 선택한다. 만일 그렇지 않으면 다음과 같은 메시지박스가 뜬다

5.  Rebuild 시킨후 ‘Profile…’ 메뉴를 선택하면 다음과 같은 다이알로그가 뜬다

6.  여기서 ‘Function timing’을 선택하고 ‘OK’를 누르면 프로그램이 실행이 될 것이다.

7.  실행이 끝나고 나면 Output 창에 결과를 보여줄 것이다. 함수별 실행시간과 불려진 횟수 등을 확인할 수 있다.

이것을 이용하면 프로그램을 짠 후 오랜 시간이 걸리거나 짧으면서도 많이 호출되는 함수를 찾아서 프로그램을 개선시킬 수가 있다. 단, 실행되는 것이 디버그모드이고 이 때는 일반 디버그모드보다 시간이 더 걸린다는 것을 명심해야 합니다. 이 외에도 프로파일에는 여러 가지 기능이 있으니 사용해 보시기 바랍니다.

-DEVPIA에 올리신 이광진(mirjini)님의 글입니다

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

각 문자열 라이브러리 함수 구현

strcpy : 문자열 복사

strlen : 문자열 길이

strcat : 문자열 붙이기

strcmp : 문자열 비교

strlwr : 대문자 -> 소문자

strupr : 소문자 -> 대문자

atoi : 문자열 -> 정수

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

#include <stdio.h>

#define ARR_SIZE 20  // 임시 배열들의 크기

#define INT_MAX (1<<31)-1  // int형 최대값

#define INT_MIN 1<<31   // int형 최저값

int menu_select(int*);   // 메뉴 함수

int input_string1(char*);   // 입력 함수(하나)

int input_string2(char*, char*); // 입력 함수(둘)

int strcpy_proc(char*, char*);  // 문자열 복사 함수

int strlen_proc(char*);   // 문자열 길이 구하는 함수

int strcat_proc(char*, char*);  // 문자열 붙이기 함수

int strcmp_proc(char*, char*);  // 문자열 비교 함수

int strlwr_proc(char*);  // 대문자 -> 소문자 함수

int strupr_proc(char*);  // 소문자 -> 대문자 함수

int atoi_proc(char*);  // 문자열 -> 정수 함수

int end_proc(void);  // 종료 함수

// 메인 함수

int main(void)

{

int nRetry=1, nSelect=0, nLength=0, nCmp=0, nNum=0;  // 프로그램 반복확인, 메뉴 선택, 문자열 길이, 문자열 비교 결과, 문자에서 정수

char sArr[ARR_SIZE]={0};   // 임시 배열(주로 복사본)

char cArr1[ARR_SIZE]={0}, cArr2[ARR_SIZE]={0};  // 임시 입력 배열

// 시작

while(nRetry)  // 반복

{

menu_select(&nSelect);   // 메뉴 함수 호출

switch(nSelect)   // 메뉴에서 선탠된 값으로 연산 선택

{

case 1 :  // 문자열 복사

input_string1(cArr1);   // 문자열 입력 함수 호출

strcpy_proc(sArr, cArr1);  // 문자열 복사 함수 호출

printf("복사된 문자열 : %s\t원본 문자열 : %s\n", sArr, cArr1);  // 결과 출력

break;

case 2 :  // 문자열 길이

input_string1(cArr1);   // 입력 함수 호출

nLength = strlen_proc(cArr1);  // 문장려 길이 구하는 함수 호출

printf("문자열 %s의 길이는 %d입니다.\n", cArr1, nLength);   // 결과 출력

break;

case 3 :  // 문자열 합치기

input_string2(cArr1, cArr2);  // 문자열 입력 함수 호출 

strcat_proc(cArr1, cArr2);   // 문자열 합치기 함수 호출

printf("합쳐진 문자열 : %s\n", cArr1);   // 결과 출력

break;

case 4 :  // 문자열 비교

input_string2(cArr1, cArr2);   // 입력 함수 호출

nCmp = strcmp_proc(cArr1, cArr2); // 문자열 비교 함수 호출

printf("%d\n", nCmp);  // 결과 출력

break;

case 5 :  // 대문자 -> 소문자

input_string1(cArr1);  // 입력 함수 호출

strlwr_proc(cArr1);   // 대문자 -> 소문자 함수 호출

printf("%s\n", cArr1);  // 결과 출력

break;

case 6 :  // 소문자 -> 대문자

input_string1(cArr1);  // 입력 함수 호출

strupr_proc(cArr1);   // 소문자 -> 대문자 함수 호출

printf("%s\n", cArr1);  // 결과 출력

break;

case 7 :  // 문자열 -> 정수

input_string1(cArr1);   // 입력 함수 호출

nNum = atoi_proc(cArr1);  // 문자열 -> 정수 함수 호출

printf("%d\n", nNum);   // 결과 출력

break;

case 8 :  // 종료

end_proc();  // 종료 메시지 함수 호출

nRetry = 0;  // 반복변수를 0으로 주어 종료

break;

}

}

return 0;

}

// 메뉴 선택 함수

int menu_select(int* pSelect)

{

puts("\n문자열 관련 라이브러리 함수 구현");

puts("================================");

puts("1. 문자열 복사 (srtcpy)");

puts("2. 문자열 길이 (strlen)");

puts("3. 문자열 붙이기 (strcat)");

puts("4. 문자열 비교 (strcmp)");

puts("5. 문자 대문자->소문자 (strlwr)");

puts("6. 문자 소문자->대문자 (strupr)");

puts("7. 문자열->정수 (atoi)");

puts("8. 종료");

do

{

fflush(stdin);

printf("메뉴를 선택하시오 : ");

scanf("%d", pSelect);

} while(*pSelect < 1 && *pSelect > 8);  // 특정 범위의 값만 받음

return 0;

}

// 입력 함수 1

int input_string1(char* pCArr)

{

fflush(stdin);

printf("문자열을 입력하시오 : ");

gets(pCArr);   // 문자열 입력

return 0;

}

// 입력 함수 2

int input_string2(char* pCArr1, char* pCArr2)

{

fflush(stdin);

printf("첫 번째 문자열을 입력하시오 : ");

gets(pCArr1);   // 문자열 입력

printf("두 번째 문자열을 입력하시오 : ");

gets(pCArr2);   // 문자열 입력

return 0;

}

// 문자열 복사 함수

int strcpy_proc(char* pSArr, char* pCArr)

{

while(*pCArr != '\0')  // 두번째 인자의 값이 '\0'이 아닐동안 반복

{

*pSArr = *pCArr;  // 두번째 인자의 각 인덱스의 값을 첫번째 인자의 같은 인덱스로 복사

pSArr++; // 인덱스(주소) 증가

pCArr++; // 인덱스(주소) 증가

}

*pSArr = *pCArr;   // 마지막 '\0'값 복사

return 0;

}

// 문자열 길이 구하는 함수

int strlen_proc(char* pCArr)

{

int nCnt=0;  // 길이 변수

while(*pCArr != '\0')  // 인자의 값이 '\0'이 아닐동안 반복

{

pCArr++;   // 인덱스(주소)증가

nCnt++;   // 길이 카운터 증가

}

return nCnt;   // 길이 값 반환

}

// 문자열 붙이기 함수

int strcat_proc(char* pCArr1, char* pCArr2)

{

int nCnt=0;

for(; ; pCArr1++)  // 첫번째 인자의 값을 증가시키면서 반복

{

if(*pCArr1 == '\0')   // 첫번째 인자의 값이 '\0' 일 경우

{

while(*pCArr2 != '\0')  // 두번째 인자의 값이 '\0'이 아닐동안 반복

{

*pCArr1 = *pCArr2;  //두번째 인자의 값을 첫번째 인자의 현재 인덱스로 복사

pCArr1++; // 증가

pCArr2++; // 증가

}

*pCArr1 = *pCArr2;   // 마지막 '\0' 복사

break;  // 종료(반복문 빠져나옴)

}

}

return 0;

}

// 문자열 비교 함수

int strcmp_proc(char* pCArr1, char* pCArr2)

{

int nCmp=0;  // 비교 값 변수

while(pCArr1 != '\0' && pCArr2 != '\0')  // 두 인자가 '\0' 이 아닐 동안 반복

{

if(*pCArr1 < *pCArr2)   // 두 번째 인자의 값이 큰 경우

{

nCmp = -1;   // 비교 값 변수에 -1 대입

break;  // 반복문 종료

}

else if(*pCArr1 > *pCArr2)  // 첫 번째 인자의 값이 큰 경우

{

nCmp = 1;   // 비교 값 변수에 1 대입

break;  // 반복문 종료

}

else  // 같을 경우

{

pCArr1++;  // 증가

pCArr2++;  // 증가

nCmp = 0;  // 비교 값 변수에 0 대입

}

}

return nCmp;  // 비교 값 변수 반환

}

// 문자열 대문자 -> 소문자

int strlwr_proc(char* pCArr)

{

while(*pCArr != '\0')  // 인자의 값이 '\0'이 아닐 동안 반복

{

if(*pCArr >= 'A' && *pCArr <= 'Z')  // 인자의 값이 'A' ~ 'Z' 이면

*pCArr += 32;   // 인자의 값에 32를 더함 (32 :대문자와 소문자의 차이 값)

pCArr++;  // 인덱스 증가

}

return 0;

}

// 문장려 소문자 -> 대문자

int strupr_proc(char* pCArr)

{

while(*pCArr != '\0')   // 인자의 값이 '\0'이 아닐 동안 반복

{

if(*pCArr >= 'a' && *pCArr <= 'z')  // 인자의 값이 'a' ~ 'z' 이면

*pCArr -= 32;  // 인자의 값에 32를 뺌 (32 :대문자와 소문자의 차이 값)

pCArr++;   // 인덱스 증가

}

return 0;

}

// 문자열에서 정수 추출

int atoi_proc(char* pCArr)

{

int nTNum=0, nSign=1, nCnt=0, nMFlag=0, nPFlag=0;  // 추출된 정수 저장, 부호, 카운터, 음수 플레그, 양수 플레그

while(*pCArr != '\0')  // 인자의 값이 '\0'이 아닐 동안 반복

{

if(*pCArr == '-' && nCnt == 0 && nMFlag == 0)  // 인자의 값이 '-' 이고 카운터가 0(숫자가 한번도 안 나온 경우)이고 부호가 최초 한번 나올 경우

{

nSign = -1;  // 부호 변수에 -1 대입

pCArr++;   // 인자 인덱스 증가

nMFlag = 1;  // 음수 부호 플레그

}

else if(*pCArr == '+' && nCnt == 0 && nPFlag == 0)  // 인자의 값이 '+' 이고 카운터가 0(숫자가 한번도 안 나온 경우)이고 부호가 최초 한번 나올 경우

{

nSign = 1;  // 부호 변수에 1 대입

pCArr++;   // 인자 인덱스 증가

nPFlag = 1;  // 음수 부호 플레그

}

else if(*pCArr == ' ' || *pCArr == '\t')  // ' '(공백)이거나 '\t'(탭) 일 경우

{

pCArr++;   // 인자 인덱스 증가

}

else if(*pCArr >= '0' && *pCArr <= '9')   // 인자의 값이 '0' ~ '9' 일 경우

{

if(nCnt > 0)  // 카운터가 0이상일 경우 (문자가 한번이라도 숫자로 변경된 경우)

nTNum *= 10;  // 추출된 정수에 10을 곱함

nTNum += ((int)*pCArr - 48);  // 인자값 - 48(ASCII 코드 0과의 차이 값)을 int형으로 변환 후 추출된 정수값 저장 변수와 더함

pCArr++;   // 인자 인덱스 증가

nCnt++;   // 카운터 증가

}

Else   // 위의 경우가 아닌 경우

break;   // 반복문 종료

}

nTNum = nTNum*nSign;  // 추출된 정수값에 부호 값을 곱해줌

// 최대 최소값 미 구현

/*

if(nTNum > INT_MAX || nTNum < INT_MIN)

nTNum = nTNum % 65536;

*/

return nTNum;  // 결과 값 반환

}

// 종료 함수

int end_proc(void)

{

puts("종료합니다.");  // 종료 메시지 출력

return 0;

}

[출처] [C 언어] 문자열 라이브러리 함수 구현|작성자 파하름

sprintf 가 printf 와 다른 것은 printf 가 stdout 즉, 콘솔화면에 찍어주는 함수인데 반해

sprintf 는 지정한 문자열에 할당 해준다는 것입니다.

사용법은 다음과 같이 쓰시면 됩니다.

a = 10;                                   

char str[100];

printf("a : %d\n", a);                 // printf는 콘솔 화면에 "a : 10" 이라고 찍는다

sprintf(str, "a : %d\n", a);         // sprintf는 str 문자열에 "a : 10" 이라는 문자열을 할당한다

printf("%s", str);                         // str 에 문자열이 제대로 들어갔는지 확인

 

원본 위치 <http://kin.naver.com/qna/detail.nhn?d1id=1&dirId=1040101&docId=67408224&qb=c3ByaW50Zg==&enc=utf8&section=kin&rank=4&sort=0&spq=0&pid=f06eqz331xGsst89Mw0ssv--179507&sid=S0KP239zQksAAHWbQMo>

그 값을 다시 배열에서 포인터로 복사

Char buffer[50];

Char *m_pszRow;

memccpy(buffer, m_pszRow, '\n', strlen(m_pszRow));

memccpy(m_pszRow, buffer, '\n', strlen(m_pszRow));