//문자를 한번에 한개씩만 출력해서 삼각형만들기
    
    /*
     
     *
     **
     ***
     ****
     *****
     
     */
    
    //출력문을 이용해서
    printf("*\n");
    printf("**\n");
    printf("***\n");
    printf("****\n");
    printf("*****\n");
    printf("\n");
    
    
    //반복문을 이용해서
    
    char star = '*';
    for (char i = 1; i < 6; i++) {
        for (char ii = 0; ii < i; ii++) {
            printf("%c",star);
        }
        printf("\n");
    }
    
    printf("\n");
    
    
    //문자를 한번에 한개씩만 출력해서 역삼각형만들기
    /*
     
     *****
      ****
       ***
        **
         *
     
     */
    
    for (char i = 6; i > 1; i--) {
        
        //공백출력
        for (char z = 6 ; z > i; z--) {
            printf(" ");
        }
        
        //별 출력
        for (char ii = 1 ; ii < i ; ii++) {
             printf("%c",star);
        }
        printf("\n");
    }

 

참고: https://blog.naver.com/tipsware/221256188057

'ios 뽀개기 > C언어' 카테고리의 다른 글

반복문 실습 - 별그리기  (0) 00:47:44
비트연산  (0) 2019.11.18
자료형  (0) 2019.11.18
c언어 기초4  (1) 2019.05.22
c언어 기초 3  (0) 2019.05.21
c언어 기초2  (0) 2019.05.17
#include <stdio.h>

//3단계 변수의 특정 비트를 0으로 만드는 예제
//dest_data 변수의 bit_num 번째 있는 비트를 0으로 설정하는 함수로 해당 비트가 0으로 설정된 값을 반환한다.
unsigned char ResetBit (unsigned char dest_data , unsigned char bit_num){
    
    //1바이트 변수라서 비트 이동은 0~7 까지 가능함
    if (bit_num < 8) {
        dest_data = dest_data & ~(0x01 << bit_num);
    }
    
    return dest_data;
}


//3단계 : 변수의 특정 비트를 1로 만드는 예제
unsigned char setBit(unsigned char dest_data, unsigned char bit_num){
    /* 1바이트 변수라서 비트 이동은 0~ 7까지 가능*/
    if (bit_num < 8) {
        dest_data = dest_data | (0x01 << bit_num);
    }
    
    return  dest_data;
}

//3단계 변수의 값을 2진수 형태로 확인하는 예제
//dest_data 변수의 bit_num 번째 비트 값을 반환하는 함수
unsigned char GetBit(unsigned char dest_data, unsigned char bit_num){
    unsigned char bit_state = 0;
    
    /* 1바이트 변수라서 비트 이동은 0 ~ 7 까지만 가능*/
    if (bit_num < 8) {
        bit_state = dest_data & (0x01 << bit_num);
        bit_state = bit_state >> bit_num;
    }
    
    /* bit_num에 지정한 비트 값을 반환함 */
    
    return bit_state;
}



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


    //####################### 비트단위 연산과 비트 패턴 #############################
    
    //c언어에서 제공하는 자료형의 최소 단위는 1바이트 이다.
    //0,1 중 하나를 저장하더라도 1바이트 저장공간을 사용해야 한다...
    //but 비트 연산자를 알면 가능하다.
    unsigned char lamp_state = 0;     /* 기본값은 전등이 꺼져 있음 */
    lamp_state = 1;                 /* 전등이 켜지면 1로 변경함 */
    
    
    
    //부호 없는 1바이트 변수를 선언하고, 그 변수에 16진수 값 5A로 초기화 하는 코드.
    //16진수 한자리는 4비트.
    unsigned char data = 0x5A;      /* 2진법 : 0101 1010 , 10진수 : 90*/
    printf("%d \n" , data);           //90
    
    
    
    //시프트 연산자
    //오른쪽에서 왼쪽으로 이동
    
    unsigned char l_data = 0x1A;        /* 이동전 : 0001 1010 */
    printf("%d \n" , l_data);          //26
    l_data = l_data << 2;            /* 이동후 : 0110 1000*/
    printf("%d \n" , l_data);          //104 (26에 2의 2승을 곱한것과 같다.)
    
    //왼쪽에서 오른쪽으로 이동
    unsigned char r_data = 0x1A;        /* 이동전 : 0001 1010*/
    printf("%d \n" , r_data);          //26
    r_data = r_data >> 2;            /* 이동후 : 0000 0110*/
    printf("%d \n" , r_data);          //6 (26에 2의 2승을 나눈것과 같다.)
    
    
    //변수에 부호가 있는경우 : 부호비트가 1이면 이동한 빈 공간에 1로 채우고, 부호비트가 0이면 이동한 공간에 0으로 채운다.
    char my_data = 0x85;
    my_data = my_data >> 3;
    
    
    //지정한 비트를 0으로 설정하기 : and 연산자 사용. 한쪽 비트가 0이면 다른쪽 비트 상관없이 0
    //1단계 - 2번 비트를 0으로 설정하기
    unsigned char l_a;        /*어떤 값이 들어있는지 알 수 없다.*/
    l_a = l_a & 0xFB;       /* 2번 비트만 0으로 변경함 , FB : 1111 1011 (2번째 비트만 0으로 설정후 and 연산)*/
    printf("%d \n" , l_a);   /* 2번째 비트만 0으로 변경됨*/
    
    
    //2단계 - 임의의 비트를 0으로 설정하기 : 16진수 0xFB를 직접 명시하지 않고 2번이라는 정보만 가지고 만들기
    unsigned char l_b;                          /* 어떤 값이 있는지 알 수 없음 */
    unsigned char bit_num = 2;                  /* 0으로 만들 비트의 번호 */
    unsigned char mask = ~(0x01 << bit_num);     /* 2번 비트로 1을 옮기고 비트를 반전시킴 */
    
    l_b = l_b & mask;                         /* l_b 의 2번째 비트만 0으로 변경됨*/
    
    
    //3단계 함수로 만들어 보기
    unsigned char sample_data = 0x7F;       /* 2진수 : 0111 1111*/
    printf("%X ->" , sample_data);          /* 값 변경전 출력*/
    //변수의 3번째 비트를 0으로 설정함.
    sample_data = ResetBit(sample_data, 3);
    printf("%X \n" , sample_data);          /* 값 변경후 출력*/
    //7F ->77
    
    
    
    //지정한 비트를 1로 설정하기 : or 사용. 한쪽 비트가 1이면 다른쪽 비트값에 상관없이 1
    //1단계 : 2번비트를 1로 설정하기
    unsigned char sample_data1;                 /* 어떤값이 있는줄 알수 없음 */
    sample_data1 = sample_data1 | 0x04;       // 변수의 2번비트만 1로 변경
    
    //2단계: 0x04를 직접 명시하지 않고 2번 비트라는 정보만 가지고 만들어본다.
    unsigned char sample_data2;
    unsigned char bit_num_new = 2;                      /* 1로 만들 비트의 번호 */
    unsigned char mask_new = 0x01 << bit_num_new;        /* 0x04 */
    sample_data2 = sample_data2 | mask_new;          /* 2번 비트만 1로 변경함*/
    

    //3단계 함수로 만들어보기: 특정 비트를 1로 만드는 예제
    unsigned char my_a_data = 0x77;         /* 2진수로 0111 0111*/
    printf("%X -> " , my_a_data);           /* 값 변경전 출력*/
    my_a_data = setBit(my_a_data, 3);      /* 변수의 3번째 비트를 1로 설정함*/
    printf("%X \n" , my_a_data);          /* 값 변경후 출력*/
    //77 -> 7F
    
    
    
    
    //특정비트 값 얻기 : 변수의 비트 패턴에서 특정 비트의 값을 얻고 싶으면 비트 and 연산자를 사용한다.
    //얻고 싶은 비트 값만 1로 넣고 나머지 비트는 모두 0을 넣어서 숫자를 만들고 and 연산을 하면된다.
    //1단계
    unsigned char a;
    unsigned char bit_state;            /*2번 비트의 값을 저장할 변수 */
    bit_state = a & 0x04;             /* a의 2번 비트만 값을 유지한 상태로 bit_state에 저장함  0x04 : 0000 0100*/
    bit_state = bit_state >> 2;     /* bit_state의 값을 0또는 1로 확인가능*/
    
    
    //2단계 : 임의의 비트 값 얻기
    unsigned char my_data2;
    unsigned char my_bit_num = 2;                   /* 1로 만들 비트 번호*/
    unsigned char my_bit_state;                     /* 비트의 값을 저장할 변수 */
    unsigned char my_mask = 0x01 << my_bit_num;     /* 비트 옮긴 후 값은 0x04*/
    my_bit_state = my_data2 & my_mask;          /* my_data2의 2번 비트만 값을 유지한 상태로 my_bit_state에 저장함*/
    my_bit_state = my_bit_state >> my_bit_num;  /* 0 또는 1로 확인가능 */
    
    //3단계 : 변수의 값을 2진수 형태로 확인하는 예제
    
    int i;
    unsigned char data_state = 0x75;                /* 2진수 : 0111 0101*/
    unsigned char l_bit_state;
    //8개의 비트 값을 모두 출력하기 위해 8번 반복함
    for (i = 0; i < 8; i++) {
        
        l_bit_state = GetBit(data_state, 7 - i);
        
        /* 비트 값을 출력함 */
        printf("%d " , l_bit_state);
    }
    
    //비트값이 모두 출력되면 줄바꿈
    printf("\n");                           //0 1 1 1 0 1 0 1
    
    
    
    //보수를 이용해서 덧셈으로 뺄셈 이용하기
    /*
     255를 0으로 만드는 숫자를 찾는방법
     1111 1111 (255)
        (비트반전)
     0000 0000 (0) - 1의 보수
     
        ( +1)
     0000 0001 (1) - 2의 보수
     
     
     
     198을 0이 되도록 숫자를 찾는법
     1100 0110 (198)
        (비트반전)
     0011 1001 (57) - 1의 보수
        (+1)
     0011 1010  (58) - 2의 보수
     
     */
    
    
    
    return 0;
}




복습

V        

do it c언어 책 참고

'ios 뽀개기 > C언어' 카테고리의 다른 글

반복문 실습 - 별그리기  (0) 00:47:44
비트연산  (0) 2019.11.18
자료형  (0) 2019.11.18
c언어 기초4  (1) 2019.05.22
c언어 기초 3  (0) 2019.05.21
c언어 기초2  (0) 2019.05.17

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

    //정수를 표현하는 자료형 세가지 : 1바이트 , 2바이트 4바이트
    
    /*부호가 있는 1바이트 저장공간 -128 - 127 저장가능 */
    signed char temperature;
    // 오류 : Implicit conversion from 'int' to 'signed char' changes value from -129 to 127
    //temperature = -129;
    
    temperature = -2;
    printf("%d \n", temperature);
    
    
    
    /* 부호가 없는 1바이트 저장공간 0 ~ 255 저장가능 */
    unsigned char age;
    age = 255;
    printf("%d \n" ,age);
    
    
    /* 부호가 있는 2바이트 저장공간 */
    //16비트 크기의 자료형이다. 첫 1비트를 부호비트로 사용해서 나머지 15비트에만 숫자를 저장한다.  -32,768 ~ -1 ,  0 ~ 32,767
    signed short int dday;
    dday = 3200;
    printf("%d \n" ,dday);
    
    
    /*부호가 없는 2바이트 저장공간*/
    //16비트 저장공간이 있기 때문에 0~ 36,000 저장가능
    unsigned short int seconds;
    seconds = 36000;
    printf("%d \n" , seconds);
    
    
    
    /*부호가 있는 4바이트 저장공간*/
    //총 32비트 중에서 부호비트 1을 뺀 31 비트의 저장공간을 가진다. -2,147,483,648 ~ -1  , 0 ~ 2,147,483,647
    signed long int money;
    money = 700000;
    
    
    /*부호가 없는 4바이트 저장공간*/
    unsigned long int time_seconds;
    //1970년 1월 1일 부터 현재 까지 흐른시간을 초단위로 환산한 값을 저장함
    time_seconds = 1453100624;
    
    
    return 0;
    }

 

복습 

V        

do it c 언어 참고

'ios 뽀개기 > C언어' 카테고리의 다른 글

반복문 실습 - 별그리기  (0) 00:47:44
비트연산  (0) 2019.11.18
자료형  (0) 2019.11.18
c언어 기초4  (1) 2019.05.22
c언어 기초 3  (0) 2019.05.21
c언어 기초2  (0) 2019.05.17
#include <stdio.h>
#include <string.h> //문자열 길이를 구하는 strlen 함수를 사용하기 위해서
#include <stdlib.h> //  atoi 함수를 사용하기 위해



int main(int argc, const char * argv[]) {
    //배열포인터
    
    //data 배열은 1 - 5 까지의 값을 저장하고 있다.
    char data[5] = {1,2,3,4,5};
    
    //합산에 사용할 result 변수는 0으로 초기화 한다.
    int result = 0, i;
    
    char *p = data; // data배열의 시작위치를 포인터 변수 p에 저장한다.
    
    //5번 반복하면서 포인터 p를 사용하여 배열의 각 항목을 result 변수에 합산
    
    for (i = 0; i < 5; i++) {
        result = result + *p;
        p++;   //data 배열의 다음 항목으로 주소를 이동 data[0] -> data[1] -> ...
    }
    
    //합산한 결과를 출력한다.
    printf("data 배열의 각 요소의 합은 %d 입니다. \n" , result);
    return 0;
}

do it c 언어 입문 참고

'ios 뽀개기 > C언어' 카테고리의 다른 글

비트연산  (0) 2019.11.18
자료형  (0) 2019.11.18
c언어 기초4  (1) 2019.05.22
c언어 기초 3  (0) 2019.05.21
c언어 기초2  (0) 2019.05.17
c언어 기초1  (0) 2019.05.16
  1. 2019.07.26 12:27

    비밀댓글입니다

#include <stdio.h>
#include <string.h> //문자열 길이를 구하는 strlen 함수를 사용하기 위해서
#include <stdlib.h>   //  atoi 함수를 사용하기 위해

 //14 - 10 문자를 정수로 변환
int ArrayToInteger(char string[]){
    
    int count = 0, num = 0;
    //문자열이 끝날때 까지 반복
    while (string[count] != 0) {
        //반복할 때마다 이전 값에 10을 곱해서 자릿수를 증가시킴
        num = num * 10 + string[count] - '0';
        count++;
        
    }
    return num;
}


/*
 buffer : 사용자가 입력한 문자열을 저장할 배열
 limit : 최대 입력 가능한 문자개수
 1반환 : 정상입력
 0반환 : 제한된 개수만 받았다
 */
int GetMyString(char buffer[] , int limit ){
    
    int i;
    for (i = 0; i <= limit; i++) {   //최대 개수만큼만 반복
        buffer[i] = getchar();
        if (buffer[i] == '\n') {    //엔터키가 체크되면 사용자의 입력이 완료되었다는 뜻, 문자열 완성, 함수 종료.
        
            buffer[i] = 0;            //엔터키 위치에 0을 넣어서 문자열 완성
            return 1;                   //정상적으로 입력이 완료됨
        }
    }
    
    //반복문을 빠져 나왔다는 뜻은 입력 개수 제한을 초과했다는 뜻
    //현재 위치에 0을 넣고 문자열 구성 완료
    buffer[i] = 0;
    rewind(stdin); //표준 입력 버퍼에 남아있는 문자들을 제거함.
    return 0;          //입력 초과 현상이 발생했음을 알림.
}


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

    /*
    //14 - 1 표준 입력 함수를 사용하여 문자를 한개 입력 받음
    int input_data;
    input_data = getchar();
    // 입력받은 문자를 출력
    printf("input : %c \n" , input_data);
    //input : d
 
    
     //14 - 2 표준 입력 함수를 사용하여 문자를 한개 입력 받음
    int input_data2;
    input_data2 = getchar();
    printf("첫문자 : %c \n" , input_data2);
    input_data2 = getchar();
    printf("둘째문자 : %c \n" , input_data2);
  
    
    //14 - 3
    int input_data3 = getchar();
    rewind(stdin);      //표준 입력 버퍼에 있는 모든 입력값을 제거함.
    printf("first input : %c\n", input_data3);
    input_data3 = getchar();
    rewind(stdin);
    printf("second input : %c\n", input_data3);
    
    
    
    //14 - 4 마지막에 0을 포함해야 하므로 최대 9개의 문자까지 저장 가능
    char input_string[10];
    gets(input_string);
    printf("input string : %s \n" , input_string);
    
    
    
    //14 - 5 반환값이 NULL이 아니라 문자열을 입력 받아서 input_string에 저장함
    char input_string2[10];
    if (NULL != gets(input_string2)) {
        printf("input_string2 : %s \n" , input_string2);
    }else{
        printf("input => canceled \n");
    }
    
    
    
    //14 - 6 입력할 문자열 개수 지정
    char temp[10];
    int state;
    //최대 9개까지만 입력받겠다고 제안함.
    state = GetMyString(temp, 9);
    if (state == 1) {
        printf("input : %s \n", temp);                          //정상입력
    }else{
        printf("input : %s -> out of range\n", temp); // 범위를 초과
    }
    
    
    //14 - 7 문자를 정수로 변환
    
     //pos_num은 각 자릿수에 곱할 숫자, num은 정수로 변환될 숫자를 저장할 변수
     
    int pos_num = 100, num = 0 , i, temp_num;
    //정수로 변환할 문자열
    char num_string[4] = "423";
    
    for (i = 0; i < 3; i++) {
        
        //배열의 각 항목을 문자에서 정수로 변경
        temp_num = num_string[i] - '0';
        printf(" temp_num -> %d \n"  , temp_num);
        //정수화된 숫자에 자릿수에 해당하는 숫자를 곱해서 합산
        num = num + temp_num * pos_num;
        
        //다음 자릿수를 구성하기 위해서 10을 나눔. 100 -> 10 -> 1
        pos_num = pos_num / 10;
    }
    printf(" %s -> %d \n" , num_string , num);
     
    
    
    
    //14 - 8 문자를 정수로 변환
    int pos_number = 1, number = 0, i , countNum;
    char number_string[4] = "123";
    //문자열의 길이를 구해서 countNum 변수에 3이저장
    countNum = strlen(number_string);
    
    //문자열의 길이보다 1만큼 작게 반복하기 위해
    //10 * 10 * 10 = 1000  이 아니라 10 * 10 해서 100이 되어야 한다.
    printf("countNum -  : %d \n" , countNum);       //3
    //반복 1회마다 10씩 증가 1-> 10 -> 100
    for (i = 0; i < countNum - 1; i ++) {
        pos_number = pos_number * 10;
        printf("pos_num -  : %d \n" , pos_number);    // 10, 100
    }
    
    //문자열의 길이 만큼 반복
        for (i = 0; i < countNum; i++) {
            number = number + (number_string[i] - '0' ) * pos_number;
            pos_number = pos_number / 10;
            printf("number - v  : %d \n" , number);                 //100    , 120
            printf("pos_num - v  : %d \n" , pos_number);        //10,    1
        }
        printf(" %s -> %d \n", number_string , number);     // 123 -> 123
    
    
     //14 - 9 문자를 정수로 변환
    int num = 0, count = 0;
    char num_string[4] = "123";
    //문자열이 끝날 때까지 반복
    while (num_string[count] != 0) {
        //반복할 때마다 이전 값에 10을 곱해서 자릿수를 증가시킴
        //num의 변화 : 1 * 10 + 1 -> 12 * 10 + 2 -> 123
        num = num * 10 + (num_string[count] - '0');
        count++;    //다음문자로 이동
        printf(" num : %d \n" , num);
        // num : 1
        //num : 12
        //num : 123
    }
    printf(" %s -> %d \n" , num_string , num);
    
    
      //14 - 10 문자를 정수로 변환 - gets
    int first_num, second_num;
    char first_string[16] , second_string[16];
    
    printf("input first number : ");
    gets(first_string);     //첫번째 숫자를 입력받음
    printf("input second number : ");
    gets(second_string);  //두번째 숫자를 입력받음
    
    first_num = ArrayToInteger(first_string);               // 문자열 -> 정수
    second_num = ArrayToInteger(second_string);    //문자열 -> 정수
    
    printf("%d + %d = %d \n" , first_num, second_num , first_num+second_num);
    
    
    
    //14 - 11 문자를 정수로 변환 - atoi
    int first_num, second_num;
    char first_string[16] , second_string[16];
    printf("input first number : ");
    gets(first_string); // 첫 번째 숫자를 입력받음
    printf("input second number : ");
    gets(second_string);   //두 번째 숫자를 입력받음
    
    first_num = atoi(first_string);
    second_num = atoi(second_string);
    // 정수로 변환된 두 수를 합산한 결과 출력
    printf("%d + %d = %d\n", first_num, second_num, first_num + second_num);
    
     
    
    //14 - 12 입력    -  scanf
    int int_data;
    float float_data;
    
    scanf("%d" , &int_data);        //정수 값을 입력 받는다.
    scanf("%f" , &float_data);      //실수 값을 입력받는다.
    printf("input : %d, %f\n", int_data, float_data);       // 5 , 55.5
    
   
    
    
     //14 - 13 입력
    char temp[32];
    scanf("%s" , temp); //문자열을 입력받음. 배열 변수 이름을 사용하면 해당 배열의 시작 주소를 의미하기 때문에 &연산자를 쓰면안된다.
    printf("input string : %s \n", temp);
    
    
     //14 - 14 진수 변환
    int num1, num2, num3;
    scanf("%o %d %x", &num1, &num2 , &num3); // 8, 10, 16진수 입력받는다.
    printf("input : %d, %d, %d \n" , num1, num2, num3);
    //10
    //10
    //10
    //input : 8, 10, 16
    
     
    
    
    //14- 15 응용
    
    int num = 0;
    //정상적인 나이를 입력할 때까지 무한 반복
    while (1) {
        printf("input age : ");
        scanf("%d" , &num);     //한개의 정수 값을 입력 받음
        
        if (num > 0 && num <= 130) {
            break;  //정상입력 -> 반복문 빠져나감
        }else{
            //나이 범위 잘못되었다고 알림
            printf("잘못된 나이! \n");
        }
    }
    
    printf("당신의 나이는 : %d  입니다.\n" , num);   //문자열 입력하면 무한반복
    
     */
    
     //14- 16 응용
    
    int num = 0;
    while (1) {
        printf("input age : ");
        
        // scanf 함수는 실패하면 0을 반환한다.
        if (scanf("%d" , &num) ==0) {
            rewind(stdin);      //입력 버퍼를 모두 비운다.
            printf("enter digit number ! \n");
        }else{
            
            
            if (num > 0 && num <= 130) {
                break;
            }else{
                printf("잘못된 나이! \n");
            }
        }
    }
    printf("당신의 나이는 %d  입니다. \n" , num);
    
    
    
    
    
    return 0;
}

'ios 뽀개기 > C언어' 카테고리의 다른 글

비트연산  (0) 2019.11.18
자료형  (0) 2019.11.18
c언어 기초4  (1) 2019.05.22
c언어 기초 3  (0) 2019.05.21
c언어 기초2  (0) 2019.05.17
c언어 기초1  (0) 2019.05.16
#include <stdio.h>
#include <string.h>
int result; //전역변수, 특별한 초기화 값이 없으면 0으로 초기화됨


 //배열 길이 구하기- 5
//매개변수 data의 [ ] 의 숫자는 적지 않아도 된다. 전달되는 배열의 크기에 영향을 받기 때문에 어떤 숫자를 적어도 무방하다.
int GetStringLength(char datas[]){
    int count = 0;
     /* 0이 나올 때까지 문자의 개수를 더한다 */
    while (datas[count]) {
        printf("배열안의 글자는 : %c \n" , datas[count]);
        /*
         배열안의 글자는 : h
         배열안의 글자는 : a
         배열안의 글자는 : p
         배열안의 글자는 : p
         배열안의 글자는 : y
         */
        count++;
    }
    return count;
}


//step3
void Test(){
    int data = 0;
    printf("%d  \n" , data++);
}

//*step2 전역변수
void Sum2(int data1, int data2){
    result = data1 + data2;
}


//*step1 지역변수 함수
int Sum(int data1, int data2){  // data1, data2는 지역변수 이다. 5와 3으로 초기화 된다.
    int result = data1 + data2; // 지역 변수, data + data2 값으로 초기화 됨.
    return result;
}






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

    //지역변수 함수 *step 1
    int result;     //지역변수, 초기화 되지 않아서 어떤 값이 들어있을지 모름
    result = Sum(5, 3);
    printf("5 + 3 = %d \n" , result);
    //5 + 3 = 8
    
    
    //전역 변수 함수;
    Sum2(6, 4);
    printf("6 + 4 = %d \n", result); // ! 주의! 전역변수 result 를 참조하지 않고 지역변수 result 를 참조한다.
    //6 + 4 = 8
    
    
    //step3
    int i ;
    for (i=0; i<5; i++) {
        Test();
    }
    /*
     0
     0
     0
     0
     0  
     */
    
    
    //step 12
    
    //배열 - 1
    short student[20];
    student[1] = 10;
   printf("%d %d\n", student[1], student[2]);
    //10 0
    
    
    //배열 - 2
    short mystudent[20], ii;
    for (ii = 0; ii < 20; ii++) mystudent[ii] = 0;
    mystudent[1] = 10;
     printf("%d %d\n", mystudent[1], mystudent[2]);
    //10 0
    

    //배열 - 3
    short yourstudent[20] = {0,};
    yourstudent[1] = 10;
     printf("%d %d\n", yourstudent[1], yourstudent[2]);
    //10 0
    
    
    char data[5] = {1,2,3,4,5};
    int resultdata = 0, iii;
    for (iii = 0; iii<5; iii++) {
        resultdata = resultdata + data[iii];
    }
    printf("data 배열의 각 요소의 합은 %d 입니다. \n" , resultdata);
    //data 배열의 각 요소의 합은 15 입니다.
    
    
    
    //배열 - 4
    char dataArray[6] = {'h' , 'a' ,'p' ,'p' , 'y', 0};
    char ment[] = "C programming~";
    printf("%s \n" , dataArray);
    //happy
    printf("%s \n" , ment);
    //C programming~
    
    
    //배열 길이 구하기- 5
    int data_length; //문자열 길이를 저장할 변수
    char dataChars[10] = {'h' , 'a' , 'p'  , 'p'  , 'y' , 0 , };
    data_length = GetStringLength(dataChars);
    printf("data length = %d \n" , data_length);
    //data length = 5
    
    
    //배열 길이 구하기- 6
    int my_data_length;
    char mydatas[10] = {'h' , 'a', 'p', 'p' , 'y' , 0, };
    my_data_length = strlen(mydatas);
    printf("data length = %d \n" , my_data_length);
    //data length = 5
    
    
    
    //배열 더하기 , 복사 - 7
    char sdata[10] = {'a' , 'b' ,'c' , 0, };
    char sresult[16] ;  //새로운 문자열을 저장할 변수
    strcpy(sresult, sdata); //sdata에 저장된 문자열을 sresult로 복사
    strcat(sresult, "def");  /* result에 “def”를 덧붙임 */
    printf("%s + \"def\" = %s\n" ,sdata , sresult);
    //abc + "def" = abcdef
    
    
    //2차원 배열 - 8
    char doublearray[3][4] = {  {0,0,2,0} ,  {1,1,0,0} , {2,1,0,2} };
    int x, y;
    
    for (y = 0;  y < 3;  y++) {
        for (x = 0; x < 4; x++) {
            printf("%d행에 %d열에" , y + 1 , x + 1);
            if (doublearray[y][x] == 1) {
                printf("검은돌이 놓여있습니다. \n");
            } else if(doublearray[y][x] == 2){
                printf("흰돌이 놓여 있습니다. \n");
            }else{
                printf("는 돌이 놓여 있지 않습니다. \n");
            }
        
        }
    }
    /*
     1행에 1열에는 돌이 놓여 있지 않습니다.
     1행에 2열에는 돌이 놓여 있지 않습니다.
     1행에 3열에흰돌이 놓여 있습니다.
     1행에 4열에는 돌이 놓여 있지 않습니다.
     2행에 1열에검은돌이 놓여있습니다.
     2행에 2열에검은돌이 놓여있습니다.
     2행에 3열에는 돌이 놓여 있지 않습니다.
     2행에 4열에는 돌이 놓여 있지 않습니다.
     3행에 1열에흰돌이 놓여 있습니다.
     3행에 2열에검은돌이 놓여있습니다.
     3행에 3열에는 돌이 놓여 있지 않습니다.
     3행에 4열에흰돌이 놓여 있습니다.
     */
    
    
    
    
    
    return 0;
}

do it c언어 도서 참고

'ios 뽀개기 > C언어' 카테고리의 다른 글

비트연산  (0) 2019.11.18
자료형  (0) 2019.11.18
c언어 기초4  (1) 2019.05.22
c언어 기초 3  (0) 2019.05.21
c언어 기초2  (0) 2019.05.17
c언어 기초1  (0) 2019.05.16
#include <stdio.h>


//더하기 함수
int Sum(int value1, int value2){
    
    int result = value1 + value2;
    return result;
    
}


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

    //step 6 자료형 -
    
    int day;        //int형 변수 선언
    day = 17;     //int형 변수에 값 대입
    printf("오늘은 몇일 ? : %d 일 \n" , day );
    //출력 : 오늘은 몇일 ? : 17 일
    
    
    int sumResult;
    sumResult = Sum(5, 6);
    printf("두 수를 더한 값 : %d \n" , sumResult);
    //출력 : 두 수를 더한 값 : 11
    
    //문자 더하기
     putchar('m');
     putchar('y');
     putchar('~');
     putchar('\n');
    //출력: my~
    
    
    //출력 후 줄바꿈
    puts("hello~!");
    //hello~!
    
    //%c와 65가 짝을 이루기 때문에 65에 해당하는 ASCII 코드값 A가 출력 된다.
    printf("65의 ASCII 값은 %c 입니다. \n" , 65);
    //출력 : 65의 ASCII 값은 A 입니다.
    
    //첫번째 data는 A와 짝을 이루고, 두번째는 %d와 짝을 이룬다.
    char data = 65;
    printf("%c 의 ASCII 값은 %d 입니다. \n", data , data);
    //출력 : A 의 ASCII 값은 65 입니다.
    
    
    //실수 출력
    float value = 2.1f;
    printf("실수 float : %f \n" , value);
    //출력 : 실수 float : 2.100000
    
    //value2 값을 실수 형식과 정수 형식으로 출력
    float value2 = 5.6f;
    printf("정수 : %d, 실수 : %f  \n" , value2, value2);
    //출력 : 정수 : 0, 실수 : 5.600000
    
    //부호가 있는 int, 부호가 없는 int
    int data1 = -1;
    unsigned int data2 = 4294967295;
    printf("%d, %u, %d, %u \n" , data1, data1, data2 , data2);
    //출력 : -1 , 4294967295, -1, 4294967295

    
    //부호가 있는 char
    char data3 = -1;
    printf("%d , %u \n", data3,data3);
    //-1 , 4294967295
    
    
    //진수 변환
    int data_1 = 10;
    int data_2 = 010;
    int data_3 = 0x10;
    printf("%x, %d, %o \n" , data_1 , data_2 , data_3);     //16진수 , 10진수, 8진수;
    //a, 8, 20
    
    
    float data_4 = 15.54;
    printf("%f, %e, %E  \n" , data_4, data_4, data_4);
    //출력 : 15.540000, 1.554000e+01, 1.554000E+01
    
    
    
    //자릿수 확인 - 자릿수확인을 위해 [ ] 문자를 사용함.
    int data_5 = 7;
    printf("[%d] [%5d] \n" , data_5 ,data_5);
    //[7] [    7]
    
    
    //자릿수 확인2
    int data_6 = 7;
    printf("[%5d] [%05d] [%-5d] \n" , data_6, data_6 , data_6);
    //[    7] [00007] [7    ]
    
    
    //자릿수 확인3
    double data_7 =3.141592;
    printf("[%f] [%.4f] [%8.4f] [%-8.4f] \n" , data_7 , data_7 , data_7 , data_7);
    //[3.141592] [3.1416] [  3.1416] [3.1416  ]
    
    
    //***************  step 7  연산 ***************
    
    int data_8, data_9;
    data_8 = 5;             //변수에 상수 5를 대입
    data_9 = data_8;    //
    printf("data_8 = %d , data_9 = %d \n" , data_8 , data_9);
    //data_8 = 5 , data_9 = 5
    
    
    //연산
    int data_10 = 5, data_11 = 3;   //두 변수에 초기값을 5와 3으로 설정
    int result1 = data_10 + data_11;        // 덧셈
    int result2 = data_10 * data_11;        // 뺄셈
     int result3 = data_10 / data_11;       //나눗셈 (몫)
     int result4 = data_10 % data_11;     // 나눗셈 (나머지)
    printf("result : %d , %d , %d, %d \n" ,result1 ,result2 , result3 , result4);
    //result : 8 , 15 , 1, 2
    
    
    //관계연산
    int data_12 = 5, data_13 = 3;           // 두 변수에 초기값을 5와 3으로 설정
    int result_1 = data_12 > 7;               //거짓 : 0
    int result_2 = data_13 <= data_12; //참 : 1
    int result_3 = data_13 == 7;            //거짓 : 0
    int result_4 = data_13 != data_12;  //참 : 1
    printf("result : %d, %d, %d, %d \n" , result_1 , result_2 , result_3, result_4);
    //result : 0, 1, 0, 1
    
    
    //연산
    int mydata1 = 5, mydata2 = 3;
    int result__1 = 0 || 1;                                                 // 0 또는 1 : 참 (1)
    int result__2 = 3 && -1;                                            // 1 && 1과 같아서 참 (1)
    int result__3 = mydata1 == 3 || mydata2 == 3;
    int result__4 = mydata1 == 3 && mydata2 ==3;    //거짓
    int result__5 = !mydata1;                                         //거짓
    printf("result : %d , %d, %d, %d, %d \n" , result__1, result__2, result__3, result__4, result__5);
    //result : 1 , 1, 1, 0, 0
    
    
        //***************  step 8  if 문 ***************
    
    //if문 - 1
    int ifData = 5;
    if(ifData > 3){     //비교 연산은 참.
        printf("ifData는 3보다 큰 수 입니다. \n");
        printf("작업종료 \n");
    }
    //ifData는 3보다 큰 수 입니다.
    //작업종료
    
    
    
    
    //if문 - 2
    int score = 92;
    char grade;
    if (score >= 90) {
        grade = 'A';
        printf("점수는 %d 이고 등급은 %c 입니다. \n" , score, grade);
    }
    printf("작업 종료 \n");
    //점수는 92 이고 등급은 A 입니다.
    //작업 종료

    //if - else 문 1
    int hisdata = 5;
    if (hisdata > 3) {
        printf("hisdata는 3보다 큰 수 입니다.  \n");
    }else{
        printf("hisdata는 3보다 작거나 같은 수 입니다.  \n");
    }
    printf("작업을 종료 합니다.  \n");
    /*
     hisdata는 3보다 큰 수 입니다.
     작업을 종료 합니다.
     */
    
    
    //if - else 문2
    
    int myscore = 92;
    char mygrade;
    
    if (myscore >= 90) {
        mygrade = 'A';
        printf("점수는 %d이고 등급은 %c 입니다. \n" , myscore, mygrade);
    } else {
        mygrade = 'B';
        printf("점수는 %d이고 등급은 %c 입니다." , myscore, mygrade);
    }
    printf("작업을 종료 합니다.  \n");
    /*
     점수는 92이고 등급은 A 입니다.
     작업을 종료 합니다.
     */
    

    //if 문 - 응용 - 1
    int year = 2015 , month = 12, days = 31;
    days++;             //일을 +1 해주기
    //일이 31일 이상이면 월 +1 해주고 일 값을 1로 초기화
    if (days > 31) {
        month++;
        days = 1;
        //달이 12일 이상이면 년을 +1 해주고 월 값을 1로 초기화
        if (month > 12) {
            year++;
            month = 1;
        }
    }
    printf("date : %d년  %d월  %d일  \n" , year, month, days);
    //date : 2016년  1월  1일
    
    
    //if 문 - 응용 - 2
    int hisscore = 80;
    char hisgrade;
    if (hisscore >= 90) {
        hisgrade = 'A';
    } else {
        if(hisscore >= 80) {
            hisgrade = 'B';
        }else {
            if(hisscore >= 70) {
                hisgrade = 'C';
            }else {
                if(hisscore >= 60) {
                    hisgrade = 'D';
                }else {
                    if(hisscore >= 50) {
                        hisgrade = 'E';
                    }else {

                            hisgrade = 'F';
                        
                    }
                }
            }
        }
    }
    printf("그의 점수는 %d점이고 등급은 %c 입니다. \n" ,hisscore, hisgrade );
    //그의 점수는 80점이고 등급은 B 입니다.
    
    
    //switch 문
    int enscore = 86;
    char engrade;
    
    switch (enscore / 10) {
        case 10:
        case  9:
            engrade = 'A';
            break;
        case  8:
            engrade = 'B';
            break;
        case  7:
            engrade = 'C';
            break;
        case  6:
            engrade = 'D';
            break;
            
        default:
            engrade = 'F';
            break;
    }
    printf("영어 점수는 %d 이고 등급은 %c 입니다 \n" , enscore , engrade );
    //영어 점수는 86 이고 등급은 B 입니다
    
    
    
    //***************  step 9  for 문 ***************
    
    int sum_ = 0, num_;
    for (num_ = 1 ; num_ <= 5 ; num_ ++ ){
        printf("num(%d) + sum(%d) = " , num_ , sum_);
        sum_ = sum_ + num_;
        printf("%d \n" , sum_);
    }
    printf("\n results = : num = %d , sum = %d \n\n" , num_ , sum_);
    
    /*
     num(1) + sum(0) = 1
     num(2) + sum(1) = 3
     num(3) + sum(3) = 6
     num(4) + sum(6) = 10
     num(5) + sum(10) = 15
     results = : num = 6 , sum = 15
     */
    
    
    //for문 2
    int numsum = 0, dnum = 1;
    //무한루프
    for(  ;  ;  ){
        printf("dnum(%d) + numsum(%d) = " , numsum, dnum);
        numsum = numsum  + dnum;
        printf("%d\n" , numsum);
        dnum++;
        if (dnum > 5) {break;}      //빠져나온다.
    }
    printf("\n Result : dnum = %d numsum = %d \n" , dnum , numsum);
    /*
     dnum(0) + numsum(1) = 1
     dnum(1) + numsum(2) = 3
     dnum(3) + numsum(3) = 6
     dnum(6) + numsum(4) = 10
     dnum(10) + numsum(5) = 15
     Result : dnum = 6 numsum = 15
     */
    
    
    //while문
    int sumW = 0 , numW = 1;
    //5보다 같거나 작을때만 반복문 실행
    while (numW <= 5) {
        printf("num(%d) + sum(%d) = " , numW , sumW);
        sumW = sumW + numW;
        printf("%d \n" , sumW);
        numW++;
    }
    printf("\n Result : dnum = %d numsum = %d \n" , numW , sumW);
    /*
     num(1) + sum(0) = 1
     num(2) + sum(1) = 3
     num(3) + sum(3) = 6
     num(4) + sum(6) = 10
     num(5) + sum(10) = 15
     Result : dnum = 6 numsum = 15
     */
    
    
    //do while 문
    int sumdo = 0 , numdo = 1;
    do{
        printf("num(%d) + sum(%d) = " , numdo, sumdo);
        sumdo = sumdo + numdo;
        printf("%d\n" , sumdo);
        numdo++;
    }while(numdo <= 5);
    printf("\n Result : numdo = %d sumdo = %d \n" , numdo , sumdo);
    /*
     num(1) + sum(0) = 1
     num(2) + sum(1) = 3
     num(3) + sum(3) = 6
     num(4) + sum(6) = 10
     num(5) + sum(10) = 15
     Result : numdo = 6 sumdo = 15
     */
    
    // 구구단 반복문
    for(int bignum = 2; bignum < 10 ; bignum ++){
        for (int smallnum = 1; smallnum < 10; smallnum++) {
            printf("%d x %d = %d \n" , bignum , smallnum, (bignum*smallnum));
        }
    }
    /*
     2 x 1 = 2
     2 x 2 = 4
    (생략..........)
     9 x 8 = 72
     9 x 9 = 81
     */
    
    return 0;
}

do it c언어 참고

'ios 뽀개기 > C언어' 카테고리의 다른 글

비트연산  (0) 2019.11.18
자료형  (0) 2019.11.18
c언어 기초4  (1) 2019.05.22
c언어 기초 3  (0) 2019.05.21
c언어 기초2  (0) 2019.05.17
c언어 기초1  (0) 2019.05.16

+ Recent posts