Nayoung Kim
pcc004

Repository

#include <stdio.h>
int main()
{
    printf("Hello World! \n");
}
cp ~hwan/.profile ~hwan/.bashrc ~hwan/.bash_logout ~
source .profile
git config --global user.name "KimNayoung"
git config --global user.email "skdud1201@ajou.ac.kr"
git config --unset --global user.name
git config --unset --global user.email
git config --list
a.out <<< 300 > out.txt // Hello stderr 300 출력
cat out.txt             // Hello stdout 300 출력
int ifuncAdd(int a, int b)
{
    return a+b;
}
#include <stdio.h>
int main() {
	int i;
	int in_a;
	fscanf(stdin, "%d", &in_a);
	for (i = 31; i >= 0; i--) {
		fprintf(stdout, "%d", ((in_a >> i) & 1));
		if (i % 4 == 0) {
			fprintf(stdout, " ");
		}
	}
	fprintf(stdout, "\n");
}
int in_a, in_b;
fscanf(stdint, "%d", &in_a);
in_b = in_a >> 2;
unsigned int in_a, in_b;
fscanf(stdint, "%d", &in_a);
in_b = in_a >> 2;
#include <stdio.h>

int count_one(int in_a)
{
        int i, count = 0;
        for(i = 31; i>=0; i--)
        {
                if((in_a>>i) & 1)
                        count++;
                // count += (in_a>>i)&1; 위의 if문 대체 가능
        }
        return count;
}

int main()
{
        int i;
        unsigned int in_a;
        fscanf(stdin, "%u", &in_a);
        fprintf(stdout, "%u \t: ", in_a);
        for(i=31; i>=0; i--)
        {
                fprintf(stdout, "%d", ((in_a>>i) & 1));
                if(i % 4==0)
                {
                        fprintf(stdout, " ");
                }
        }
        fprintf(stdout,": %d \n", count_one(in_a));
}
int count_one(int in_a)
{
        int i=32, count = 0;
        while (i>0)
        {
            count += (in_a>>i) & 1;
            i--;
        }
        return count;
}
int static_check(int a)
{
    int static numCalls = 0;
    fprintf(stderr, "Call : %d\n", numCalls);
    numCalls++;
}

int main()
{
    int num;
    fscanf(stdin, "%d", &num);
    static_check(num);
    static_check(num);
    static_check(num);
    static_check(num);
    static_check(num);
}
Call : 0
Call : 1
Call : 2
Call : 3
Call : 4
int static_check(int a)
{
    int numCalls = 0;
    fprintf(stderr, "Call : %d\n", numCalls);
    numCalls++;
}

int main()
{
    int num;
    fscanf(stdin, "%d", &num);
    static_check(num);
    static_check(num);
    static_check(num);
    static_check(num);
    static_check(num);
}
Call : 0
Call : 0
Call : 0
Call : 0
Call : 0
#include <stdio.h>

int main()
{
    int a = 100;
    int b = 200;

    fprintf(stdout, "%d : %d\n", a, &a);
    fprintf(stdout, "%d : %d\n", b, &b);
}
#include <stdio.h>

void add(int *a, int *b, int *c)
{
        *c = *a + *b;
}

int main()
{
        const int a = 100;
        int b = 200;
        const int c = 999;

        fprintf(stdout, "%d : %lld\n", a, &a);
        fprintf(stdout, "%d : %lld\n", b, &b);
        add(&a,&b,&c); //1
        c = a+b; //2

        fprintf(stdout, "%d : %lld\n", c, &c);
        int d=999;
        fprintf(stdout, "%d :%lld  %lld\n", d, ((void *)(&d))+1, &d+1);
}
#include <stdio.h>

int sumArray3(int a[3], int sum)
{
        sum = *a;
        a++;
        sum += *a;
        a++;
        sum += *a;
        fprintf(stdout, "%d : %lld %llx\n", sum, &sum, &sum);
        return a[3];
}

int main()
{
        int a = 100;
        int b = 200;
        int c = 999;
        int arr[4] = {100,200,300,400};
        int *parr;
        parr = arr;
        parr++;
        fprintf(stdout, "%d : %lld %lld\n", *parr, parr, arr);
        c = sumArray3(arr, b);
        fprintf(stdout, "%d : %lld %llx\n", b, &b, &b);

        fprintf(stdout, "%d : %lld %llx\n", *arr, *arr, *arr);
        fprintf(stdout, "%d : %lld %llx\n", &arr, &arr, &arr);
        fprintf(stdout, "%d : %lld %llx\n", arr[2], &arr[2], &arr[2]);
        fprintf(stdout, "%d : %lld %llx\n", arr[3], &arr[3], &arr[3]);
        fprintf(stdout, "%d : %lld %llx\n", arr[4], &arr[4], &arr[4]);
        fprintf(stdout, "%d : %lld %llx\n", arr[4000], &arr[4000], &arr[4000]);

}
#include <stdio.h>

void addPointer(int *a, int *b, int *c) // Call by Address
{
        *c =  *a + *b;
        fprintf(stdout, "In addPointer A %d : %lld %llx\n", *a, a, a);
        fprintf(stdout, "In addPointer B %d : %lld %llx\n", *b, b, b);
        fprintf(stdout, "In addPointer C %d : %lld %llx\n", *c, c, c);
        *a = -100;
        *b = -200;
}

int addValue(int a, int b, int c) // Call by Value
{
        c =  a + b;
        fprintf(stdout, "In addValue A %d : %lld %llx\n", a, &a, &a);
        fprintf(stdout, "In addValue B %d : %lld %llx\n", b, &b, &b);
        fprintf(stdout, "In addValue C %d : %lld %llx\n", c, &c, &c);
        a = 999; b=888;
        return c;
}

int main()
{
        int a = 100;
        int b = 200;
        int c = 999;

        fprintf(stdout, "%d : %lld %llx\n", a, &a, &a);
        fprintf(stdout, "%d : %lld %llx\n", b, &b, &b);
        addPointer(&a,&b,&c);
        fprintf(stdout, "%d : %lld %llx\n", c, &c, &c);
        // a = 200; b = 300;
        c = addValue(a,b,c);
        fprintf(stdout, "%d : %lld %llx\n", a, &a, &a);
        fprintf(stdout, "%d : %lld %llx\n", b, &b, &b);
        fprintf(stdout, "%d : %lld %llx\n", c, &c, &c);
}
100 : 140732089039420 7ffebe2cfa3c
200 : 140732089039424 7ffebe2cfa40
In addPointer A 100 : 140732089039420 7ffebe2cfa3c
In addPointer B 200 : 140732089039424 7ffebe2cfa40
In addPointer C 300 : 140732089039428 7ffebe2cfa44
300 : 140732089039428 7ffebe2cfa44
In addValue A -100 : 140732089039388 7ffebe2cfa1c
In addValue B -200 : 140732089039384 7ffebe2cfa18
In addValue C -300 : 140732089039380 7ffebe2cfa14
-100 : 140732089039420 7ffebe2cfa3c
-200 : 140732089039424 7ffebe2cfa40
-300 : 140732089039428 7ffebe2cfa44
const int a = 100;
int *p = &a;
fprintf(stdout, "a : %d\n", a); // 100
*p = 200;
fprintf(stdout, "a : %d\n", a); // 200
#include <stdio.h>
#define FN_ADD 0
#define FN_SUB 1
#define FN_MUL 2
#define FN_DIV 3
#define FN_ERR 4

void add(int *a, int *b, int *c)
{ *c = *a + *b; }

void sub(int *a, int *b, int *c)
{ *c = *a - *b; }

void mul(int *a, int *b, int *c)
{ *c = (*a) * (*b); }

void div(int *a, int *b, int *c)
{ *c = (*a) / (*b); }

int main()
{
        int a, b, c;
        char ch;
        int op = FN_ERR; // default is err

        scanf("%d %c %d", &a, &ch, &b);

        void (*fp[4])(int *, int *, int *) = {add, sub, mul, div};
        switch (ch)
        {
                case '+':
                        op = FN_ADD;
                        break;
                case '-':
                        op = FN_SUB;
                        break;
                case '*':
                        op = FN_MUL;
                        break;
                case '/':
                        op = FN_DIV;
                        break;
                default :
                        op = FN_ERR;
                        break;
        }

        fp[op](&a,&b,&c);
        if(op == 4){
                fprintf(stdout, "wrong input\n");
                return 0;
        }
        fprintf(stdout, "%d \n", c);
}
#ifdef 매크로 // 매크로가 정의되어 있다면 #ifdef, #endif 사이의 코드를 컴파일
코드
#endif
#ifndef 매크로 // 매크로가 정의되어 있지 않다면 #ifndef, #endif 사이의 코드를 컴파일
코드
#endif
#include <stdio.h>
#define DEBUG

int main() {
#ifdef DEBUG // #ifdef는 위에서 매크로가 선언된 경우 내부 코드가 실행됨
        printf("Debug : %s \t %s \t %s \t %d \n", __DATE__, __TIME__, __FILE__, __LINE__);
#endif

        char name[] = "Nayoung";
        int age = 21;

#ifndef INTRO // #ifndef는 위에서 매크로가 선언되지 않은 경우 내부 코드를 실행함
        printf("Name : %s \t Age : %d \n", name, age);
#endif
        return 0;
}
#if 값 또는 식
코드
#endif
#include <stdio.h>
#define DEBUG_LEVEL 2

int main()
{
#if DEBUG_LEVEL >= 2 // DEBUG_LEVEL이 2보다 크거나 같으면 #if, #endif 사이의 코드를 컴파일
        printf("Debug Level 2 \n");
#endif

#if 1 // 조건이 항상 참이므로 내부 코드 컴파일
    printf("It is 1 \n");
#endif

#if 0 // 조건이 항상 거짓이므로 내부 코드 컴파일하지 않음
    printf("It is 0 \n");
#endif

        return 0;
}
#if (defined DEBUG || defined TEST) && !defined (VERSION_10)
// DEBUG 또는 TEST가 정의되어 있으면서 VERSION_10이 정의되어 있지 않을 때
#include <파일>
#include "파일"
    #ifndef _MATH_
    #include <math.h>
    #endif
        inline 반환값자료형 함수이름(매개변수자료형 매개변수이름)
        {
        }
        #include <stdio.h>
        inline int add(int a, int b)
        {
            return a+b;
        }
        int main()
        {
            int num1;
           /*
            num1 = inline int add(10, 20)
            {
                return 10 + 20;
            }
            */
            // 주석 부분을 컴파일러가 함수를 복제해서 넣어줌!
            printf("%d", num1);
        }
#define str(s) #s
str(p = "foo\n";) // outputs "p = \"foo\n\";"
str(\n) // outputs "\n"

#define xstr(s) str(s)
#define str(s) #s
#define foo 4
str (foo) // outputs "foo"
xstr (foo) // outputs "4"
#define DECLARE_STURCT_TYPE(name) typedef struct name##_s name##_t

DECLARE_STRUCT_TYPE(g_object);
// Outputs: typedef struct
g_object_s g_object_t;

//다른 예제
#include <stdio.h>
#define paster( n ) printf( "token" #n " = %d", token##n )
int token9 = 9;

int main()
{
   paster(9); // output : token9 = 9
}
        #define NUMBERS 1, \
                        2, \
                        3

        int x[] = { NUMBERS };
        //int x[] = {1,2,3};
        foo = X;
        #define X 4
        bar = X; // foo = X and bar = 4

        #define TABLESIZE BUFSIZE
        #define BUFSIZE 1024
        // TABLESIZE == BUFSIZE ==1024

        #define BUFSIZE 1020
        #define TABLESIZE BUFSIZE
        #undef BUFSIZE
        #define BUFSIZE 37 // TABLESIZE = 37
    #define min (X, Y) ((X) < (Y) ? (X) : (Y))
    x = min(a,b); -> ((a) < (b) ? (a) : (b));
    y = min(1,2); -> ((1) < (2) ? (1) : (2));
    z = min(a + 28, *p) -> z = ((a+28) < (*p) ? (a+28) : (*p));
        #define str(s) #s
        #define foo 4
        str(foo) // "foo"
        #define COMMAND(name) { #name, name##_command }
        COMMAND(quit) // { "quit", quit_command }
    eprintf ("%s:%d: ", input_file, lineno)
        -> fprintf (stderr, "%s:%d: ", input_file, lineno)

    #define eprintf(format, ...) fprintf (stderr, format __VA_OPT__(,) __VA_ARGS__)
#include <stdio.h>
// #### #### #### #### . #### #### #### ####
// S 15 . 16
#define FX_Q_NUM 16
#define FX_2_MINUS_16 1.52587890625e-05F
#define FX_2_PLUS_16 (1<<16)
#define FX_S_15_16 11516
#define FX_SYSTEM FX_S_15_16

typedef int fixed32;

fixed32 fromFloat(float fa)
{
        return (fixed32) (fa * FX_2_PLUS_16);
}

float toFloat(fixed32 xa)
{
        return ((float) (xa)) * FX_2_MINUS_16;
}

fixed32 fxAdd(fixed32 a, fixed32 b)
{
        return fromFloat(toFloat(a)+toFloat(b));
}


fixed32 fxAdd2(fixed32 a, fixed32 b)
{
        return a+b;
}

int main()
{
        int i = 0;
        int ia, ib, ic, ic2;
        float fa;
        fscanf(stdin, "%d %d", &ia, &ib);
        for (i = 0; i < 64*256*256*256; i+=(256*256)){
                ic = fxAdd(i, i);
                ic2 = fxAdd2(i, i);
                fprintf(stdout, "%f + %f : %f, %f diff = %d \n", toFloat(i), toFloat(i), toFloat(ic), toFloat(ic2), ic-ic2);
        }

        fprintf(stdout, "%d + %d : %d \n", ia, ib, ic);
}
typedef int fx_s17_14;
typedef fx_s17_14 fixed;
#include <stdio.h>

typedef unsigned int t_rgba;

// input value must be 0~255

/*
방법 1. 함수 만들기
unsigned int fromRGBA(int r, int g, int b, int a)
{

        if (r > 255 || r < 0)
                r = 0;
        if (g > 255 || g < 0)
                g = 0;
        if (b > 255 || b < 0)
                b = 0;
        if (a > 255 || a < 0)
                a = 0;
        if문 성능 나빠짐


        // return r*256*256*256 + g*256*256 + b*256 + a*1;
        // return ((r<<24)+(g<<16)+(b<<8)+a);
        // return ((r<<(24+g))<<(16+b))<<(8+1);
        // return (r<<24|g<<16|b<<8|a);
        return ((r&0xff)<<24)|((g&0xff)<<16)|((b&0xff)<<8)|(a&0xff);
}
*/

// 방법 2. macro
#define fromRGBA(r,g,b,a) ((((r)&0xff)<<24)|(((g)&0xff)<<16)|(((b)&0xff)<<8)|((a)&0xff))
#define F_NUM_1_255       (1.0f/255.0f)

t_rgba mul_float(t_rgba c1, t_rgba c2){
        float r1, g1, b1, a1;
        float r2, g2, b2, a2;
        int   ir, ig, ib, ia;

        r1 = (float) ((c1 >> 24) & 0xff) * F_NUM_1_255;
        g1 = (float) ((c1 >> 16) & 0xff) * F_NUM_1_255;
        b1 = (float) ((c1 >>  8) & 0xff) * F_NUM_1_255;
        a1 = (float) ((c1 >>  0) & 0xff) * F_NUM_1_255;

        r2 = (float) ((c2 >> 24) & 0xff) * F_NUM_1_255;
        g2 = (float) ((c2 >> 16) & 0xff) * F_NUM_1_255;
        b2 = (float) ((c2 >>  8) & 0xff) * F_NUM_1_255;
        a2 = (float) ((c2 >>  0) & 0xff) * F_NUM_1_255;

        ir = (int) ((r1 * r2) * 255.0f);
        ig = (int) ((g1 * g2) * 255.0f);
        ib = (int) ((b1 * b2) * 255.0f);
        ia = (int) ((a1 * a2) * 255.0f);

        return fromRGBA(ir, ig, ib, ia);
}

t_rgba mul_int(t_rgba c1, t_rgba c2)
{
        unsigned int r1, g1, b1, a1;
        unsigned int r2, g2, b2, a2;
        unsigned int  r,  g,  b,  a;

        r1 =  c1 >> 24         ; r2 =  c2 >> 24        ;
        g1 = (c1 >> 16) & 0xff ; g2 = (c2 >> 16) & 0xff;
        b1 = (c1 >> 16) & 0xff ; b2 = (c2 >>  8) & 0xff;
        a1 =  c1        & 0xff ; a2 =  c2        & 0xff;

        r= (r1 * r2) / 255;
        g= (g1 * g2) / 255;
        b= (b1 * b2) / 255;
        a= (a1 * a2) / 255;

        return fromRGBA(r,g,b,a);

}

int main()
{
        int red, green, blue, alpha;
        t_rgba rgba_1, rgba_2, rgba_3;
        // input value must be 0~255 : 0.0~1.0
        // rgba_1 [rrrrrrrr][gggggggg][bbbbbbbb][aaaaaaaa]
        printf("input 4 values with 0~255 : ");
        scanf("%d %d %d %d", &red, &green, &blue, &alpha);
        rgba_1 = fromRGBA(red, green, blue, alpha);
        printf("%d %d %d %d : %u 0x%08x\n", red, green, blue, alpha, rgba_1, rgba_1);
        rgba_2 = mul_float(rgba_1, rgba_1);
        printf("%d %d %d %d : %u 0x%08x\n", red, green, blue, alpha, rgba_2, rgba_2);
        rgba_3 = mul_int(rgba_1, rgba_1);
        printf("%d %d %d %d : %u 0x%08x\n", red, green, blue, alpha, rgba_3, rgba_3);
}
input 4 values with 0~255 : 127 127 127 127
127 127 127 127 : 2139062143 0x7f7f7f7f
127 127 127 127 : 1061109567 0x3f3f3f3f
127 127 127 127 : 1061109567 0x3f3f3f3f
#pragma once

#define FX_S17_14       ((1<<16) | (17<<8) | (14))

// Operation Preference
#define FX_OP_FLOAT             1
#define FX_OP_PRECISION         2
#define FX_OP_FAIR              3
#define FX_OP_PERFORMANCE       4
#include "fx_head.h"
#include <math.h>

#define FX_POINT                FX_S17_14

#define FX_Q_NUM                (FX_POINT & 0xFF)               // 14

// If you want calculate with high precision set 64
#define FX_SYSTEM_INTEGER       64                              // 32 or 64
#define FX_SYSTEM_FLOAT         64                              // 32 or 64

#define FX_DATA_TYPE            signed int


typedef int fx_s17_14;
typedef fx_s17_14 fixed;

#define  fromDouble(d)          ((fixed)((d)*DOUBLE_Q_VALUE))
#define  toDouble(d)            ((double)(d)*DOUBLE_1_Q_VALUE)
#define  fromFloat(d)           ((fixed)((d)*FLOAT_Q_VALUE))
#define  toFloat(d)             ((float)(d)*FLOAT_1_Q_VALUE)

// CONSTANTS
#define  FLOAT_Q_VALUE          (float)(1<<FX_Q_NUM)
#define  DOUBLE_Q_VALUE         (double)(1<<FX_Q_NUM)
#define  FLOAT_1_Q_VALUE        (float)(1.0f/FLOAT_Q_VALUE)
#define  DOUBLE_1_Q_VALUE       (double)(1.0f/DOUBLE_Q_VALUE)
#define  FX_PI                  fromDOUBLE(M_PI)

// One of FX_OP_FLOAT, FX_OP_PRECISION, FX_OP_FAIR, FX_OP_PERFORMANCE
#define FX_OP_PREFERENCE        FX_OP_FLOAT

extern fixed fxAdd_float(), fxAdd_precision(), fxAdd_fair(), fxAdd_performance();
extern fixed fxSub_float(), fxSub_precision(), fxSub_fair(), fxSub_performance();
extern fixed fxMul_float(), fxMul_precision(), fxMul_fair(), fxMul_performance();
extern fixed fxDiv_float(), fxDiv_precision(), fxDiv_fair(), fxDiv_performance();
#include "fx_s17_14.h"
#include <stdio.h>


int main()
{

        printf("%f : %d\n",1.0, fromDouble(1.0));
        printf("%f : %f\n",1.3*0.3, toFloat(fxMul_float(fromDouble(1.3),fromDouble(0.3)))) ;

}
목표파일 : 목표파일을 만드는데 필요한 구성요소들
    목표를 달성하기 위한 명령 1
    목표를 달성하기 위한 명령 2
clean :
    rm *.o projectfile
CMAKE_MINIMUM_REQUIRED (VERSION 2.8)
PROJECT ("andromeda")
SET (PROJECT_VERSION_MAJOR 0)
SET (PROJECT_VERSION_MINOR 1)
SET (CMAKE_BUILD_TYPE Debug)
SET (CMAKE_VERBOSE_MAKEFILE true)
#include <stdlib.h>
int system(const char *command);
    execl("/bin/sh", "sh", "-c", command, (char *) 0);
int execl(const char *path, const char *arg, ...
    /* (char *) NULL */);
#include <stdio.h>

FILE *popen(const char *command, const char *type);
#include <streads.h>
#include <stdio.h>

int run(void *arg)
{
    printf("Hello world of C11 threads.");
    return 0;
}

int main(int argc, const char *argv[])
{
    thrd_t thread;
    int result;
    thrd_create(&thread, run, NULL);
    thrd_join(&thread, &result);
    printf("Thread return %d at the end \n", result);
}
#include <pthread.h>
#include <stdio.h>

void *run (void *arg)
{
    printf("Hello world of POSIX threads.");
    return 0;

}

int main()
{
	pthread_t thread;
	int result;
	pthread_create(&thread, NULL, run, NULL );
	pthread_join(thread, &result);
	printf("Thread return %d at the end\n", result);
}