'C' 카테고리의 글 목록

string processing

| C/string processing 2011. 1. 9. 15:41

Posted by 인뜨라야

#include <stdio.h>

#define TRUE    1
#define FALSE   0

void disp(char ch, int (*fp)(char)) {
        if (fp(ch)) printf("TRUE\n");
        else printf("FALSE\n");
}

int myisalnum(char ch) {
        if ((ch >= 'a' && ch <= 'z') ||
                        (ch >= 'A' && ch <= 'Z') ||
                        (ch >= '0' && ch <= '9')) {
                return TRUE;
        } else {
                return FALSE;
        }
}

int mystrlen(const char* str)
{
        int i;
        for (i = 0; str[i] != '\0'; ++i);

        return i;
}

int mystrcpy(char* buf, const char* str)
{
        int i;
        for (i = 0; str[i] != '\0'; ++i) {
                buf[i] = str[i];
        }
        buf[i] = '\0';

        return i;
}

int mystrcat(char *buf, const char* str)
{
        int i;
        int j;
        for (i = 0; buf[i] != '\0'; ++i); //최종적으로 i는 '\0'의 위치에 있음 (buf[i] == '\0')
        for (j = 0; str[j] != '\0'; ++i, ++j) {
                buf[i] = str[j];
        }
        buf[i] = '\0';

        return j;
}

int mystrrev(char *str)
{
        int i;
        int len;
        char temp;

        for (i = 0; str[i] != '\0'; ++i); //i는 문자열의 길이가 됨
        len = i;
        //printf("%d\n", len);

        for (i = 0; i < len / 2; ++i) {
                temp = str[i];
                str[i] = str[len - i - 1];
                str[len - i - 1] = temp;
        }
        str[len] = '\0';

        //debug start
        printf("mystrrev debug : ");
        for (i = 0; str[i] != '\0'; ++i) {
                printf("%c", str[i]);
        }

        if (str[i] == '\0') printf("NULL\n");
        //debuf end

        return i;
}

int mystrcmp(char *str1, char *str2)
{
        int i;
        int len1, len2;
        int len;

        for (i = 0; str1[i] != 0; ++i);
        len1 = i;

        for (i = 0; str2[i] != 0; ++i);
        len2 = i;

        //긴 문자열의 길이를 구한다.
        len = (len1 > len2) ? len1 : len2;

        for (i = 0; i < len; ++i) {
                //같은 위치의 문자를 비교한다.
                if (str1[i] > str2[i]) {
                        return 1;
                } else if (str1[i] < str2[i]) {
                        return -1;
                }

                //둘 중 하나가 '\0'이 되면 앞의 문자들이 모두 같다는 것이다.
                if (str2[i] == '\0') {
                        return 1;
                } else if (str1[i] == '\0') {
                        return -1;
                }
        }

        return 0;
}

int main()
{
        int i;
        int (*fp[2])(char);

        char *str;
        char dest[10];
        char rstr[] = "abcdef";

        fp[0] = myisalnum;
        fp[1] = myisalnum;
        for (i = 0; i < 2; ++i) {
                disp('/', fp[i]);
        }

        str = "abc";
        i = mystrlen(str); //3
        printf("mystrlen : [%s] %d\n", str, i);
        i = mystrlen("\0"); //0
        printf("mystrlen : [%s] %d\n", str, i);

        mystrcpy(dest,str);
        printf("mystrcat : dest [%s]\n", dest);

        str = "def";
        mystrcat(dest, str);
        printf("mystrcat : dest [%s]\n", dest);

        mystrrev(rstr);
        printf("mystrrev : %s\n", rstr);

        i = mystrcmp("abc", "abc");
        printf("mystrcmp : %d\n", i);

        return 0;
}

저작자표시 비영리 변경금지

And

itoa 대신 sprintf

| C 2010. 6. 26. 22:57

Posted by 인뜨라야

char* itoa(n)

{

static char buf[20];

sprintf(buf, "%s", n);

return buf;

}

char* buf[20]; 하면 리턴된 후 buf는 사라지므로 에러

static char* buf[20];

대신 동적 할당을 사용하면??

while(n) 100 10 1 0

{

cnt++; 1 2 3

n /= 10; 10 1 0

}

char* buf = (char*)malloc(sizeof(char)*cnt);

저작자표시 비영리 변경금지

'C' 카테고리의 다른 글

volatile (0)	2010.06.26
포인터 상수 (0)	2010.06.24
문자열 (0)	2010.06.13
구조체 (0)	2010.06.12
버블 정렬 c 0609 (0)	2010.06.09

And

volatile

| C 2010. 6. 26. 17:01

Posted by 인뜨라야

C complier는 프로그래머가 작성한 소스코드를 최척화하여 컴파일한다.

int a;

a = 10;

a = 20;

a = 30;

이라고 작성하면 C Compiler는 가운데 2줄은 쓸데없는 것으로 인식하고 바로 a에 30의 값을 넣어버린다.

이를 Memory-mapped IO라고 해보자.

#define PORTF (*(unsigned char *)0x62)

PORTF가 자주 쓰이므로 컴파일러는 0x62가 가리키는 메모리에 직접 값을 쓰거나 읽는 대신 cpu의 레지스터 하나에 값을 쓰거나 읽도록 최적화해버립니다.

그러면 여덟개의 스위치를 무작위로 누르면서 PINC에 값을 변화시키면 이 값은 실제 메모리인 0x62에 쓰여지지 않고 cpu의 레지스터에만 써버리기 때문에 PORTF에는 값이 쓰여지지 않게 된다. 그래서 스위치를 눌러도 LED에 불이 들어오지 않는다.

이를 막기 위해 volatile 키워드를 쓴다.

#define PORTF (*(volatile unsigned char *)0x62)

이렇게 해주면 컴파일러는 최적화를 하지 않는다. 항상 0x62가 가리키는 메모리에 값을 쓰거나 읽는다.

따라서 스위치를 누를때마다 그 값이 실제 메모리 상에 쓰여지게 되므로 LED에 불이 들어온다.

while(1)

{

PORTF = PINC;

}

저작자표시 비영리 변경금지

'C' 카테고리의 다른 글

itoa 대신 sprintf (0)	2010.06.26
포인터 상수 (0)	2010.06.24
문자열 (0)	2010.06.13
구조체 (0)	2010.06.12
버블 정렬 c 0609 (0)	2010.06.09

And

포인터 상수

| C 2010. 6. 24. 13:46

Posted by 인뜨라야

#include <stdio.h>

int main(void) {

int arr[4] = {1, 2, 3, 4};

printf("&arr = %p\n", &arr); // 0012FF54

printf("arr = %p\n", arr); // 0012FF54

printf("&arr[0] = %p\n", &arr[0]); // 0012FF54

return 0;

}

arr과 &arr 이 출력하는 메모리주소는 분명 같습니다만,

그 의미에는 미묘한 차이가 있습니다.

익히 아시고 계신 것처럼 arr은 &arr[0] 과 같은 의미이며, 그 data type은 배열의 data type입니다.

즉 arr + 1의 의미는 arr[0]에서 int형의 size만큼, 4byte 이동한 주소, &arr[1]을 의미할 수 있습니다

하지만 &arr은 그렇지 않습니다. &arr은 arr이라는 이름의 int형 4개짜리 일차원 배열의 시작주소입니다.

이것은 즉 (&arr) + 1 이 &arr[1] 을 의미하지 않음을 말합니다.

이러한 맥락에서 (&arr) + 1은 arr[0]에서 int형의 size*배열의 데이터 갯수(4) 를 곱한만큼 이동한 곳

의 주소입니다. 다음의 코드를 봐주세요.

int a[4] = {0, 1, 2, 3};

int (*pa)[4] = &a; /* 그냥 a를 쓰면 에러가 납니다 &a[0]과 &a는 의미하는 바가 달라서입니다

pa는 int형의 데이터 4개를 가지는 일차원배열을 가리키는 포인터입니다 */

pa++; /* 메모리 주소가 sizeof(int) * 4(배열데이터갯수) 만큼 이동합니다 */

printf("%d\n", (*pa)[-1]); /* pa가 가리키는 일차원 배열을 참조한 후 -1 인덱스,

즉 이는 a[3]을 의미합니다 */

출력되는 값은 물론 3입니다 :)

PS) int (*pa)[4]; /* 위에 나온대로 일차원배열을 가리키는 포인터를 선언합니다 */

int *pa[4]; /* int형의 포인터 4개를 가지는 일차원배열을 선언합니다 */

저작자표시 비영리 변경금지

'C' 카테고리의 다른 글

itoa 대신 sprintf (0)	2010.06.26
volatile (0)	2010.06.26
문자열 (0)	2010.06.13
구조체 (0)	2010.06.12
버블 정렬 c 0609 (0)	2010.06.09

And

문자열

| C 2010. 6. 13. 15:06

Posted by 인뜨라야

#문자열

1) 문자 : 끝에 NULL('\0') 문자가 없다.

2) 문자 배열 : 끝에 NULL('\0') 문자가 없다.

2) 문자열 : 문자 배열이면서 끝에 NULL('\0') 문자가 있다.

#문자열 상수

printf("%p\n", 1)

printf("%p\n", '1')

printf("%p\n", "1")

모두 상수이므로 코드 영역에 할당된다.

1) 문자 상수 : 작은 따옴표(')를 이용하여 표시

ex) 'a', '3', '%', '+'

2) 문자열 상수 : 큰 따옴표(")를 이용하여 표시

ex) "This is a string."

#상수 테이블

1) 심볼 테이블 : 프로그램 내의 모든 변수의 정보가 기록되어 있다.

2) 상수 테이블 : 프로그램 내의 모든 상수의 정보가 기록되어 있다.

문자열 "string"

%d로 출력 -> "string"의 시작주소

%p로 출력 -> "string"

#문자열 선언

char carray[] = {'a', 'b', 'c'};

연속된 3개의 공간에 문자 'a', 'b', 'c'가 값으로 들어가 있는 문자 배열이다.

char string1[] = {'a', 'b', 'c', '\0'};

연속된 4개의 공간에 문자 'a', 'b', 'c'와 NULL('\0') 문자가 들어가 있는 문자열이다.

각각의 문자가 코드 영역에 순서대로 할당되고, 'a'의 시작주소가 string1에 대입된다.

메모리 할당은 코드 영역에 될까? 스택 영역에 될까?

char string2[] = "abc";

"abc"는 코드 영역에 'a', 'b', 'c', '\0'으로 할당되어 있고, 스택 영역에 배열로 할당된다???

string2에는 다른 값을 대입할 수 없다. 주소이기 때문이다. 각각의 문자변수([0], [1], [2], [3])에 값을 넣어야 바꿀 수 있다.

char *string3 = "abc";

"abc"는 코드 영역에 'a', 'b', 'c', '\0'으로 할당되어 있고, 스택 영역에 할당된 string3에 "abc"의 시작 주소가 들어가 있다.

string3에는 다른 값을 대입할 수 있다. 포인터 변수이기 때문이다.

#잘못된 문자열 선언

char string[3] = "abc";

#gets()

원형 : char *gets(char *str);

읽은 문자열을 가리키는 포인터를 반환하며, 오류가 발생하면 NULL을 반환한다.

개행문자가 나올 때까지 읽어서, 개행문자 이전까지의 문자열에 NULL 문자를 붙인 문자열을 만든 후, 매개변수가 가리키는 메모리 공간에 저장하고, 그 시작 주소를 반환한다.

1)scanf() : 단어 입력

2)gets() : 문장 입력

#puts()

원형 : int puts(char *str)

매개변수가 가리키는 값을 출력하고 마지막에 개행문자를 자동으로 출력한다.

정상적으로 실행한 후 마지막 출력문자를 반환한다. 대부분의 경우 '\n'을 출력한다.

오류가 발생하면 EOF를 반환한다.

#포인터 변수의 초기화

포인터 변수를 초기화하지 않으면 경고 메시지를 보여준다.

#문자열 함수

1) int strlen(char *s)

2) int strcmp(char *s1, char *s2)

3) int strncmp(char *s1, char *s2, int n)

4) char *strcpy(char *s1, char *s2)

5) char *strncpy(char *s1, char *s2, int n)

6) char *strcat(char *s1, char *s2)

7) char *strchr(const char *string, int c)

8) char *strrchr(const char *string, int c)

9) int atoi(const char *s)

10)int itoa(int value, char *string, int radix)

#문자열 배열

char strings[N][M] = {"string1", "string2", "string3", ... "stringN" };

최대 M의 길이를 가지는 문자열 N개를 작성할 수 있다.

코드 영역에 N개의 문자열 공간이 할당되고, 스택에도 N*M만큼의 공간이 할당된다.

#문자열 포인터 배열

char *strings[N] = {"string1", "string2", "string3", ... "stringN" };

길이 제한 없는 문자열 N개를 작성할 수 있다.

코드 영역에 N개의 문자열 공간이 할당되고, 스택에는 그 문자열의 시작주소를 가리키는 4*N만큼의 공간이 할당된다.

메모리 공간이 절약되고 문자열을 편리하게 다룰 수 있다.

원본 문자열 배열의 시작 주소만 가지는 포인터 배열은 원본의 변경없이 포인터만 바꿔주면 정렬 등의 기능을 수행할 수 있다.

#main() 함수

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

argc, argv는 관례적으로 사용하는 것이며, 사용자가 바꿀 수 있다.

공백을 포함한 문자열을 큰따옴표로 묶으면 하나의 인수로 인식한다.

#문자 함수

1) int isalnum(int c)

2) int isalpha(int c)

3) int iscntrl(int c)

4) int isdigit(int c)

5) int isgraph(int c)

6) int islower(int c)

7) int is print(int c)

8) int ispunct(int c)

9) int isspace(int c)

10) int isupper(int c)

11) int isxdigit(int c)

12) tolower(int ch)

13) toupper(int ch)

#문자열

char string = "test";

string = string+0 = &string[0]

*string = *(string+0) = string[0]

string + 1 = &string[1]

*(string + 1) = *&string[1] = string[1]

*(1+string) = *&1[string] = 1[string]

printf("%p\n", "abc");

배열크기는 변수로 지정할 수 없다??? 디파인된 상수로는 가능??

저작자표시 비영리 변경금지

'C' 카테고리의 다른 글

volatile (0)	2010.06.26
포인터 상수 (0)	2010.06.24
구조체 (0)	2010.06.12
버블 정렬 c 0609 (0)	2010.06.09
다중포인터 (0)	2010.06.08

And

구조체

| C 2010. 6. 12. 19:50

Posted by 인뜨라야

#사용자 정의 자료형 (typedef)

새로운 자료형을 정의하는데 사용한다.

긴 이름의 자료형을 짧게 정의할 수 있다.

정의 예)

typedef unsigned char BYTE;

typedef unsigned WORD;

typedef int VECTOR[3];

크기가 3인 int형 배열을 VECTOR라는 자료형으로 정의

typedef char* STRNIG;

문자를 가리키는 포인터형을 STRING이라는 자료형으로 정의

선언 예)

BYTE ch;

WORD aword;

VECTOR matrix3;

크기가 3인 int형 배열 matrix3을 선언하였다. 총 12바이트의 메모리 공간을 차지한다.

STRING aString;

char형 포인터 변수 aString을 선언하였다. 포인터 변수이므로 4바이트의 메모리 공간을 차지한다.

#구조체

배열 :

의미상 서로 연관된 자료형이 동일한 자료들을 하나의 이름으로 묶은 것이다.

각각의 요소를 접근하기 위해서는 배열이름[index]를 사용한다.

구조체 :

의미상 서로 연관이 되지만 자료형이 서로 다른 자료들을 하나의 이름으로 묶은 것이다.

각각의 요소를 접근하기 위해서는 구조체 변수이름.멤버이름를 사용한다.

구조체와 배열을 서로 중첩하여 정의할 수 있어 복잡한 구조의 자료를 효울적으로 구성할 수 있다.

1) 구조체의 원형을 정의한 후, 변수를 선언하는 방법 (태그 있음)

struct student { char name[20]; int english; int math; }; struct student st1; struct student st2;

구조체 변수 st1, st2가 만들어졌다.

2) 구조체의 원형과 변수의 선언을 동시에 하는 방법 (태그 있음)

struct student { char name[20]; int english; int math; } st1; struct student st2;

구조체 변수 st1, st2가 만들어졌다.

3) 구조체의 원형을 정의한 후, 단 한 번만 변수로 사용하는 방법 (태그 없음)

struct {
    char name[20];
    int english;
    int math;
} st1;

구조체 변수 st1은 만들어졌으나 struct 뒤에 태그가 없어 Noname Type이 되어 st2를 만들 수 없다.

만드려면 아래와 같은 방법이 있다.

struct {
    char name[20];
    int english;
    int math;
} st1, st2;

struct {
    char name[20];
    int english;
    int math;
} st1;
struct {
    char name[20];
    int english;
    int math;
} st2;

4) typedef을 이용하여 구조체의 자료형을 새로운 자료형으로 정의하는 방법 (struct를 생략할 수 있음, 가장 많이 사용)

typedef struct _student {
    char name[20];
    int english;
    int math;
} student;
student st1;

#구조체의 초기화

typedef struct {
    int x;
    int y;
} POINTER;
POINTER p1 = { 0, 0 };
POINTER p2 = { 0, 0 };

초기값이 구조체 멤버의 자료형과 일치해야 한다.

배열은 복사가 불가능하지만 구조체는 복사가 가능하다. 따라서 다음과 같이 할 수 있다.

POINTER p1 = { 0, 0 };

p2 = p1;

#구조체 배열

일반적으로 구조체는 구조체 배열이나 연결리스트의 노드로 많이 사용된다.

typedef struct {
    char name[15];
    char countryp20];
    int age;
} STUDENT;

STUDENT st[5];

#구조체 포인터

구조체 변수의 시작주소를 값으로 저장한다.

typedef struct {
    char name[15];
    char country[20];
    int age;
} STUDENT;

STUDENT *sp;

구조체 멤버 접근 방법

1) (*sp).name = "Jack";

2) sp->name = "Jack";

2)의 방법을 많이 쓴다.

#구조체와 함수

1) 구조체 변수의 멤버를 함수의 인수로 전달하는 경우

인수의 갯수가 많아진다.

2) 구조체 변수를 함수의 인수로 전달하는 경우

구조체 변수 전체의 값이 전달되므로 구조체의 용량이 큰 경우 좋지 않다.

3) 구조체 변수의 주소를 인수로 전달하는 경우

인수의 갯수도 많지 않으며, 값이 아닌 시작주소만 전달되므로 인수 1개당 4바이트만 차지한다.

#구조체 변수는 복사가 가능하고 배열은 복사가 불가능한 이유

구조체는 변수이므로 메모리 공간을 의미한다. 따라서 '메모리 공간 = 메모리 공간'이 되어 대입이 가능하다.

반면에 배열은 이름 자체가 배열의 시작주소를 의미한다. 따라서 '주소 = 주소'가 되어 대입이 불가능하다.

따라서 for문을 이용하여 복사한다. 단, 문자 배열인 경우는 strcpy()를 사용할 수 있다.

#구조체 사이즈 출력

구조체에 멤버를 선언하면 4바이트보다 작은 멤버는 같이 묶여 4바이트 내에 할당된다.

char, char, short --> 4바이트

short, char, char --> 4바이트

char, short, char --> 8바이트

구조체 자체는 새로 정의한 타입 자체이므로 구조체 타입으로 만든 변수가 아닌 구조체 자체는 메모리에 할당되지도 않으며, 따라서 값 자체를 가지지 못한다.

저작자표시 비영리 변경금지

'C' 카테고리의 다른 글

포인터 상수 (0)	2010.06.24
문자열 (0)	2010.06.13
버블 정렬 c 0609 (0)	2010.06.09
다중포인터 (0)	2010.06.08
16진수 0xffffffff의 값 (signed and unsigned) (0)	2010.06.06

And

버블 정렬 c 0609

| C 2010. 6. 9. 14:22

Posted by 인뜨라야

Makefile

linux0609.zip

ㄹㄹ

버블 정렬

#include <stdio.h>

void bubble_sort(int array[], int count);
void swap(int *px, int *py);
void printVector(int V[], int n);

int main()
{
	int vector[5] = {5, 4, 3, 2, 1};
	bubble_sort(vector, 5);

	return 0;
}

void bubble_sort(int array[], int count)
{
	int i;
	int j;

	for (i = 0; i < count - 1; ++i)
	{
		for (j = 0; j < count - 1 - i; ++j)
		{
			if (array[j] > array[j+1])
			{
				swap(&array[j], &array[j+1]);
				printVector(array, 5);
			}
		}
		printf("\n");
	}
}

void swap(int *px, int *py)
{
	int temp = *px;
	*px = *py;
	*py = temp;
}

void printVector(int V[], int n)
{
	int i;
	for (i = 0; i < n; ++i)
	{
		printf("%5d", V[i]);
	}
	printf("\n");
}

Output:

    4    5    3    2    1
    4    3    5    2    1
    4    3    2    5    1
    4    3    2    1    5

    3    4    2    1    5
    3    2    4    1    5
    3    2    1    4    5

    2    3    1    4    5
    2    1    3    4    5

    1    2    3    4    5

#include <stdio.h>

int main()
{
    int i, j;
    int array[3][4] = {
    	{15, 23, 45, 56},
    	{34, 53, 76, 23},
    	{98, 29, 48, 43}};

    int *p = *array;

    for (i = 0; i < 12; ++i)
    {
    	printf("%d ", *(p+i));
    }
    printf("\n");

    return 0;
}

배열과 포인터 값과 주소 관계

#include <stdio.h>

int main()
{
	int i, j;
	int array[3][4] = {
		{15, 23, 45, 56},
		{34, 53, 76, 23},
		{98, 29, 48, 43}};

	int *p = *array;

	for (i = 0; i < 12; ++i)
	{
		printf("%d ", *(p+i));
	}
	printf("\n");

	printf("%p\n", &array[4]);
	printf("%p\n", array+4);
	printf("\n");

	printf("%p\n", array);
	printf("%p\n", array[0]);
	printf("%p\n", &array[0][0]);
	printf("\n");

	printf("%p\n", &array[0][0]);
	printf("%p\n", &array[1][0]);
	printf("%p\n", &array[2][0]);
	printf("\n");

	printf("%p\n", array[0]);
	printf("%p\n", array[1]);
	printf("%p\n", array[2]);
	printf("\n");

	printf("%p\n", array+0);
	printf("%p\n", array+1);
	printf("%p\n", array+2);
	printf("\n");

	printf("%p\n", &array+0);
	printf("%p\n", &array+1);
	printf("%p\n", &array+2);
	return 0;
}

Output:

15 23 45 56 34 53 76 23 98 29 48 43 
0xbf560034
0xbf560034

0xbf55fff4
0xbf55fff4
0xbf55fff4

0xbf55fff4
0xbf560004
0xbf560014

0xbf55fff4
0xbf560004
0xbf560014

0xbf55fff4
0xbf560004
0xbf560014

0xbf55fff4
0xbf560024
0xbf560054

저작자표시 비영리 변경금지

'C' 카테고리의 다른 글

문자열 (0)	2010.06.13
구조체 (0)	2010.06.12
다중포인터 (0)	2010.06.08
16진수 0xffffffff의 값 (signed and unsigned) (0)	2010.06.06
형식 지정자 (0)	2010.06.06

And

다중포인터

| C 2010. 6. 8. 15:09

Posted by 인뜨라야

다중포인터

#include <stdio.h>

int main()
{
    int i = 100;
    int *p = &i;
    int **pp = &p;
    int ***ppp = &pp;

    printf("     i = 100; --> i = %d\n", i);

    *p = 90;
    printf("    *p =  90; --> i =  %d\n", i);

    **pp = 80;
    printf("  **pp =  80; --> i =  %d\n", i);

    ***ppp = 70;
    printf("***ppp =  70; --> i =  %d\n", i);

    return 0;
}

Result--------------------------------------------------------------------------------------------------------------

     i = 100; --> i = 100
    *p =  90; --> i =  90
  **pp =  80; --> i =  80
***ppp =  70; --> i =  70

Result--------------------------------------------------------------------------------------------------------------

저작자표시 비영리 변경금지

'C' 카테고리의 다른 글

구조체 (0)	2010.06.12
버블 정렬 c 0609 (0)	2010.06.09
16진수 0xffffffff의 값 (signed and unsigned) (0)	2010.06.06
형식 지정자 (0)	2010.06.06
상수의 표기 (0)	2010.06.06

And

16진수 0xffffffff의 값 (signed and unsigned)

| C 2010. 6. 6. 11:20

Posted by 인뜨라야

#include <stdio.h>

int main()
{
    int inum;

    inum = 0xffffffff;

    printf("%8s   %8s %10s\n", "hexa", "type", "decimal");
    printf("%8x : %8s %10d\n", inum, "signed", inum);
    printf("%8x : %8s %10u\n", inum, "unsigned", inum);

    return 0;
}

RESULT-------------------------------------------------------------------------------------------------------------

    hexa       type    decimal
ffffffff :   signed         -1
ffffffff : unsigned 4294967295

RESULT-------------------------------------------------------------------------------------------------------------

저작자표시

'C' 카테고리의 다른 글

버블 정렬 c 0609 (0)	2010.06.09
다중포인터 (0)	2010.06.08
형식 지정자 (0)	2010.06.06
상수의 표기 (0)	2010.06.06
sizeof 연산자를 이용한 Data Type 크기 확인 (0)	2010.06.06

And

형식 지정자

| C 2010. 6. 6. 10:49

Posted by 인뜨라야

printf()	scanf()	형식
%c	%c	단일 문자
%s	%s	문자열
%d	%d	부호있는 정수
%i		부호있는 정수
	%i	10진수, 8진수, 16진수
%f	%f	실수 (십진 표기)
%e	%e	실수 (지수 표기)
%g		실수
%u	%u	부호없는 정수
%x	%x	부호없는 16진수
%o	%o	부호없는 8진수
%p		16진수 메모리 주소

printf()		형식
%ld		long int
%hd		short int
%lo		long int 8진수
%lx		long int 16진수
%u		unsigned int
%lu		unsigned long int
%lf		double
%Lf		long double

저작자표시

'C' 카테고리의 다른 글

다중포인터 (0)	2010.06.08
16진수 0xffffffff의 값 (signed and unsigned) (0)	2010.06.06
상수의 표기 (0)	2010.06.06
sizeof 연산자를 이용한 Data Type 크기 확인 (0)	2010.06.06
Data type 사이의 대입 및 출력 형식 (0)	2010.06.05

And

bsp 오픈플랫폼 과정

Article Category

Notice

Recent Article

Recent Comment

Recent Trackback

'C'에 해당되는 글 17건

string processing

itoa 대신 sprintf

'C' 카테고리의 다른 글

volatile

'C' 카테고리의 다른 글

포인터 상수

'C' 카테고리의 다른 글

문자열

'C' 카테고리의 다른 글

구조체

'C' 카테고리의 다른 글

버블 정렬 c 0609

'C' 카테고리의 다른 글

다중포인터

'C' 카테고리의 다른 글

16진수 0xffffffff의 값 (signed and unsigned)

'C' 카테고리의 다른 글

형식 지정자

'C' 카테고리의 다른 글

Tag Cloud

Calendar

Archive

My Link

티스토리툴바