sw 보관소: 헤드 퍼스트 C

2. 전처리기 지시자

#include <stdio.h> 이게 전처리기 지시자

전처리기 헤더 파일의 내용을 파일 안에 넣는거~
언제나 소스코드 제일 앞에 오고 #으로 시작

#define 는 매크로 만드는 지시자
매크로는 프로그램을 실행하는 동안 값이 바뀌지 않기 때문에 변수가 아니고
매크로는 프로그램이 컴파일 되기 전에 바뀜.

3. static 키워드

예제)

int count = 0;
int counter()
{
return ++count; //호출될 때 마다 값을 증가 시킴
}

이 코드의 문제는 count라는 전역 변수를 사용함.
어떤 함수도 사용해서 값을 바꿀 수가 있음.
전역 변수를 특정 함수나 파일만 사용할 수 있는 변수를 만드는 법~!

int counter()
{
static int count = 0;
return ++count;
}

static 키워드를 사용하면 변수를 전역 메모리에 보관하고 다른 함수가 접근하면 에러 발생

함수 앞에 static를 사용하면 같은 소스코드 안에 있는 코드만 이 함수를 사용가능

1줄 요약: static 키워드는 코드의 범위를 통제~

4. sizeof 키워드

어떤 범위를 알고 싶을 때 사용.

예제)

#include <stdio.h>
#include <limits.h>

int main()
{
printf("이 컴퓨터에서 int 형은 %lu바이트를 차지 합니다. \n", sizeof(int));
printf("그리고 int형은 %i에서 %i까지 저장할 수 있습니다. \n", INT_MIN, INT_MAX);
printf("그리고 short형은 %i에서 %i까지 저장할 수 있습니다. \n", SHRT_MIN, SHRT_MAX);
return 0;
}

매크로 이름은 INT(int), LONG(long), CHAR(char), FLT(float), DBL(double)
에 _MAX 나 _MIN을 붙이면 됨.

부록 1 중요한 10가지 이야기 중 1. 연산자

1. 연산자

증가과 감소
++i
i의 값을 1 증가시키고, 새 값을 반환

i++
i의 값을 1 증가시키고 이전 값을 반환

--i
i의 값을 1 감소시키고, 새 값을 반환

i--
i의 값을 1 감소시키고, 이전 값을 반환

1줄 요약 ++ -- 가 앞에 있으면 새 값을 반환하고, 뒤에 있으면 원래 값은 그대로

3항 연산자
어떤 값이 참일 때는 1번을 거짓일 때는 2번을 선택하고 싶다면??

(x == 1) ? 2 : 3

이라고 썼다면 x == 1이 참이면 2, 거짓이면 3

비트 조작
~a a에 있는 각 비트의 반대값을 반환합니다.
a&b a와 b의 각 비트의 논리곱을 반환합니다.
a|b a와 b의 각 비트의 논리합을 반환합니다.
a^b a와 b의 각 비트의 XOR을 반환합니다.
<< 모든 비트를 오른쪽 인자의 수만큼 왼쪽으로 이동
>> 모든 비트를 오른쪽 인자의 수만큼 오른쪽으로 이동

콤마를 사용해 수식을 분리
루프를 돌 때두 개 이상의 연산을 하는법

for(i = 0; i < 10; i++, j++) 콤마(,)로 구분~

12강 보충 - 스레드를 제어해 보장~

#include <stdio.h>
#include <pthread.h>

int beers = 2000000;

void* drink_lots(void* a)
{
int i;
for (i = 0; i < 100000; i++) {
beers = beers - 1;
}
return NULL;
}

int main()
{
pthread_t threads[20];
int t;
printf("벽에 있는 맥주병 개수: %i\n맥주병 개수: %i\n", beers, beers);
for (t = 0; t < 20; t++) {
pthread_create(&threads[t], NULL, drink_lots, NULL);
}

void* result;
for (t = 0; t < 20; t ++) {
pthread_join(threads[t], &result);
}

printf("벽에 %i 병의 맥주가 남아있습니다.\n", beers);
return 0;
}

200 만개의 병을 20개의 쓰레드를 이용하여 10만개씩 동시에 세는 프로그램임.

pthread_create 로 스레드 생성하고, pthread_join로 종료할 때가지 기다리고...

하지만 위의 소스를 실행하면 서로 공유 변수를 쓰기 때문에 계산이 개판이 됨.

고로 스레드를 통제하는 뮤텍스를 이용해 봅시당~

#include <stdio.h>
#include <pthread.h>

int beers = 2000000;
pthread_mutex_t beers_lock = PTHREAD_MUTEX_INITIALIZER;

void* drink_lots(void* a)
{
int i;
pthread_mutex_lock(&beers_lock);
for (i = 0; i < 100000; i++) {
beers = beers - 1;
}
pthread_mutex_unlock(&beers_lock);
printf("맥주 = %i\n", beers);
return NULL;
}

int main()
{
pthread_t threads[20];
int t;
printf("벽에 있는 맥주병 개수: %i\n맥주병 개수: %i\n", beers, beers);
for (t = 0; t < 20; t++) {
pthread_create(&threads[t], NULL, drink_lots, NULL);
}

void* result;
for (t = 0; t < 20; t ++) {
pthread_join(threads[t], &result);
}

printf("벽에 %i 병의 맥주가 남아있습니다.\n", beers);
return 0;
}

굵게 표시한 부분이 스레드를 통제하는 함수(라기보단 전처리기) 입니다.
lock 와 unlock 로 나뉘는데요~
이걸 반복문 전후로 사용법이 있고......

for (i = 0; i < 100000; i++)
{
pthread_mutex_lock(&beers_lock);
beers = beers - 1;
pthread_mutex_unlock(&beers_lock);
}

반복문 안에서 할수도 있습니다.
물론 둘의 과정은 틀리지만 결과는 같습니다.
어느 것이 좋다고는 말할 수는 없지만 최소한 잘못된 참조로 계산이 틀리지는 않습니다.

헤드 퍼스트 C 12강 (thread)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h> //포직스 스레드 라이브러리 사용

void error(char* msg)
{
fprintf(stderr, "%s: %s\n", msg, strerror(errno));
exit(1);
}

void* does_not(void *a)
{
int i = 0;
for (i = 0; i < 5; i++) {
sleep(1);
puts("Does not!");
}
return NULL;
}

void* does_too(void *a)
{
int i = 0;
for (i = 0; i < 5; i++) {
sleep(1);
puts("Does too!");
}
return NULL;
}

int main()
{
pthread_t t0;
pthread_t t1;
if (pthread_create(&t0, NULL, does_not, NULL) == -1)
error("t0 스레드를 생성할 수 없습니다.");
if (pthread_create(&t1, NULL, does_too, NULL) == -1)
error("t1 스레드를 생성할 수 없습니다.");

void* result;
if (pthread_join(t0, &result) == -1)
error("t0 스레드를 종료할 수 없습니다.");
if (pthread_join(t1, &result) == -1)
error("t1 스레드를 종료할 수 없습니다.");

return 0;
}

------------------ 이 코드는 스레드가 충동하는 문제가 있음 -----------

2013년 1월 23일 수요일

헤드 퍼스트 C 11강 (노크노크 서버)

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <signal.h>

void error(char* msg)
{
fprintf(stderr, "%s: %s\n", msg, strerror(errno));
exit(1);
}

int open_listener_socket()
{
int s = socket(PF_INET, SOCK_STREAM, 0);
if (s == -1)
error("소켓을 열 수 없습니다.");

return s;
}

void bind_to_port(int socket, int port)
{
struct sockaddr_in name;
name.sin_family = PF_INET;
name.sin_port = (in_port_t)htons(30000);
name.sin_addr.s_addr = htonl(INADDR_ANY);
int reuse = 1;
if (setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(int)) == -1)
error("소켓에 재사용 옵션을 설정할 수 없습니다.");
int c = bind(socket, (struct sockaddr*)&name, sizeof(name));
if (c == -1)
error("소켓에 바인딩할 수 없습니다.");
}

int catch_signal(int sig, void (*handler)(int))
{
struct sigaction action;
action.sa_handler = handler;
sigemptyset(&action.sa_mask);
action.sa_flags = 0;
return sigaction(sig, &action, NULL);
}

int say(int socket, char* s)
{
int result = send(socket, s, strlen(s), 0);
if (result == -1)
fprintf(stderr, "%s: %s\n", "클라이언트에 메시지를 보낼 수 없습니다.", strerror(errno));
return result;
}

int listener_d;

void handle_shutdown(int sig)
{
if (listener_d)
close(listener_d);

fprintf(stderr, "안녕!\n");
exit(0);
}

int read_in(int socket, char* buf, int len)
{
char* s = buf;
int slen = len;
int c = recv(socket, s, slen, 0);
while ( (c > 0) && (s[c-1] != '\n')) {
s += c; slen -= c;
c = recv(socket, s, slen, 0);
}
if ( c < 0 )
return c;
else if (c == 0)
buf[0] = '\0';
else
s[c-1] = '\0';
return len - slen;
}

int main(int argc, char* argv[])
{
if (catch_signal(SIGINT, handle_shutdown) == -1)
error("인터럽트 처리기를 설정할 수 없습니다.");

listener_d = open_listener_socket();
bind_to_port(listener_d, 30000);
if (listen(listener_d, 10) == -1)
error("들을 수 없습니다.");

struct sockaddr_storage client_addr;
unsigned int address_size = sizeof(client_addr);
puts("연결을 기다립니다.");
char buf[255];
while(1) {
int connect_d = accept(listener_d, (struct sockaddr*)&client_addr, &address_size);
if (connect_d == -1)
error("두 번째 소켓을 열 수 없습니다.");
if (say(connect_d, "인터넷 노크노크 프로토콜 서버\r\n버전 1.0\r\nKnock Knock!\r\n") != -1) {
read_in(connect_d, buf, sizeof(buf));
if (strncasecmp("Who's there?", buf, 12))
say(connect_d, "'Who's there?'라고 질문했어야 합니다!");
else {
if (say(connect_d, "Oscar\r\n") != -1) {
read_in(connect_d, buf,sizeof(buf));
if (strncasecmp("Oscar who?", buf, 10))
say(connect_d, "'Oscar who?'라고 질문했어야 합니다!");
else
say(connect_d, "Oscar silly question, you get a silly answer.\r\n");
}
}
}
close(connect_d);
}
return 0;
}

헤드 퍼스트 C 11강 (socket)

gcc 컴파일러로 해야함 vs로 할 시 헤더 파일이 틀려서 안됨.

헤드 퍼스트 C 11강, 12강

은 귀찮아서 생략한다 -_-

헤드 퍼스트 C 10강

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <string.h>
#include <errno.h>
#include <signal.h>

int score = 0;

void end_game(int sig)
{
printf("\n최종 점수: %i\n", score);
exit(0);
}

int catch_signal(int sig, void (*handler)(int))
{
struct sigaction action;
action.sa_handler = handler;
sigemptyset(&action.sa_mask);
action.sa_flags = 0;
return sigaction(sig, &action, NULL);
}

void times_up(int sig)
{
puts("\n시간 초과!");
raise(SIGINT);
}

void error(char* msg)
{
fprintf(stderr, "%s: %s\n", msg, strerror(errno));
exit(1);
}

int main()
{
catch_signal(SIGALRM, times_up);
catch_signal(SIGINT, end_game);
srandom(time(0));

while(1) {
int a = random() % 11;
int b = random() % 11;
char txt[4];
alarm(5);
printf("\n%i 곱하기 %i는? ", a, b);
fgets(txt, 4, stdin);
int answer = atoi(txt);
if (answer == a * b)
score++;
else
printf("\n틀렸습니다! 점수: %i\n", score);
}

return 0;
}