#include<stdio.h>

int main(){
  printf("Helloworld");
  return 0;
}

void printHello();

#include<stdio.h>
#include"hello.h"
int main(){
  printHello();
  return 0;
}

void encrypt(char *message);

void encrypt(char *message)
{
	char c;
	while(*message)
	{
		*message = *message ^ 31;
		message ++ ;
	}
}
}

#include <stdio.h>
#include "encrypt.h"

int main()
{
	char msg[80];
	while (fgets(msg,80,stdin))
	{
		encrypt(msg);
		printf("%s", msg);
	}
}

encrypt.o: encrypt.c encrypt.h
	gcc -c encrypt.c
message_hider.o: message_hider.c encrypt.h
	gcc -c message_hider.c
message_hider: message_hider.o encrypt.o
	gcc message_hider.o encrypt.o -o message_hider

struct fish 
{
	const char*name;
	int length;
	int age;	
};

struct fish tuna = {"tom", 10, 2}; 
printf("Fish name : %s ,length: %d, age: %d" ,tuna.name, tuna.length, tuna.age);

typedef struct fish 
{
	const char*name;
	int length;
	int age;	
}fish;

void foo(fish *tuna)
{
	printf("Fish name: %s", tuna->name);
}

typedef union 
{ 
	short count; 
	float weight; 
	float volume;
} quantity;

typedef enum color 
{
	RED,GREEN,BLUE
}COLOR;

typedef struct year
{
	unsigned int month:12; 12 < 2^4
	unsigned int day:31; 31 < 2^5
} year;

fish *f = malloc(sizeof(fish));//申请内存

printf("Fish name is %s", f.name);

free(f);//释放内存

char *_abc = "abcd";
char *_123 = "1234";
char *str1 = strdup(_abc); // 没有释放对 "1234" 的拷贝
char *str1 = strdup(_123);
free(str1);

int add(int a, int b );

int main()
{
	// 函数指针说明
	int (* add_dup)(int,int);
	add_dup = add;

	printf("2 + 3 = %d", add_dup(2,3));
}

int add(int a, int b)
{
	return (a + b);	
}

void qsort(void *array, size_t length, size_t item_size, int (*compare)(const *void,const *void))
{
	void *a;
	void *b;
	...
	if( compare(a,b))
	...
} 

int compare(const void* a, const void *b)
{
	int a = *(int*)a;
	int b = *(int*)b;
	return (a - b);
}

int main()
{
	int array[] = {1,2,7,5,8,3,4};

	qsort(array, 7, sizeof(int), compare);
}

gcc -I/my_header_files test_code.c /my_object_files/encrypt.o /my_object_files/checksum.o -o test_code

#inlcude<xxx.h>
...

gcc test_code.c -lxxxx -o test_code 

gcc -I/my_header test_code.c -L/my_lib -lhfsecurity -o test_code

//The r means the .a file will be updated if it already exists
//The c means that the archive will be created without any feedback.
//The s tells ar to create an index at the start of the .a file.
ar -rcs libxxxx.a xxxx1.o xxxx2.o //

> nm libl.a
libl.a(libmain.o): 
00000000000003a8 s EH_frame0
				 U _exit 
0000000000000000 T _main     // Text 表示这是一个函数
00000000000003c0 S _main.eh 
				 U _yylex

libl.a(libyywrap.o): 
0000000000000350 s EH_frame0 
0000000000000000 T _yywrap 
0000000000000368 S _yywrap.eh >

//-fPIC: This tells gcc that you want to create position-independent code
//Position-independent code can be moved around in memory.
gcc -I/includes -fPIC -c xxxx.c -o xxx.o
gcc -shared xxxx.o -o xxx.so // 使用 -shared 生成动态链接库
gcc *.c -lxxx -o xxx         // 像使用静态链接库一样使用动态链接库

int main()
{
	system("say 'Something changes , something never'");
}

#include<unistd.h>
#include<sys/types.h>
#include<stdio.h>

int main()
{
	pid_t pid;
	pid = fork();

	printf("Hello process\n");
}

Hello process
Hello process

➜  system  cat fork.c 
#include<unistd.h>
#include<sys/types.h>
#include<stdio.h>

int main()
{
	pid_t pid;
	pid = fork();

	if(!pid){
		printf("Hello, I'm child  process-%d \n",getpid());
	}else{
		printf("Hello, I'm father  process-%d \n",getpid());
	}
}
➜  system  vi fork.c 
➜  system  gcc fork.c && ./a.out
Hello, I'm father  process-7486 
Hello, I'm child  process-7488 

void diediedie(int sig); 			//处理信号的函数， sig 是需要处理的信号
....
int catchsignal()
{
	struct sigaction action;		//Create a new action 
	action.sa_handler = diediedie;  //This is the name of the function you want the computer to call.
	sigemptyset(&action.sa_mask);   //The mask is a way of filtering the signals that the sigaction will handle
	action.sa_flags = 0;			//These are some additional flags. You can just set them to zero.
									//Tell the operating system about it
	return sigaction(SIGINT, &sigaction, NULL); 
}

#include <stdio.h> 
#include <signal.h> 
#include <stdlib.h>

void diediedie(int sig) 
{
	puts ("Goodbye cruel world....\n");
	exit(1); 
}

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 main() 
{
	if (catch_signal(SIGINT, diediedie) == -1)
	 { 
		fprintf(stderr, "Can't map the handler"); 
		exit(2);
	}
	char name[30]; 
	printf("Enter your name: "); 
	fgets(name, 30, stdin);
	printf("Hello %s\n", name); 
	return 0;
}

#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);   		
void bind_to_port(int socket, int port);
int open_listener_socket();
int say(int socket, char *s);
int read_in(int socket, char *buf, int len);
int catch_signal(int sig, void (*handler)(int));
void handle_shutdown(int sig);

int listener_d;

int main()
{
	if(catch_signal(SIGINT, handle_shutdown) == -1) 
		error("Can't set the interrupt handler");
	listener_d = open_listener_socket();
	bind_to_port(listener_d, 3000);
	if(listen(listener_d, 10) == -1)
		error("Can't listen");
	
	struct sockaddr_storage client_addr;
	unsigned int address_size = sizeof(client_addr);
	puts("Waiting for connection");
	char buf[255];
	
	while(1)
	{
		int connect_d = accept(listener_d, (struct sockaddr *)&client_addr, &address_size);
		if( connect_d == -1)
			error("Can't open secondary socket");
		if( say(connect_d, 
		"Internet KK Protocol Server\r\n V1.0\r\nKnock!Knock!\r\n"
			) != -1 )
		{
			read_in( connect_d, buf, sizeof(buf));
			say(connect_d, "I'm a response!");
		}
		close(connect_d);
	}
	return 0;
}

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

void bind_to_port(int socket, int port)
{
	struct sockaddr_in name;
	name.sin_family = PF_INET;
	name.sin_port = (in_port_t)htons(3000);
	name.sin_addr.s_addr = htonl(INADDR_ANY);
	
	int reuse = 1;
	if(setsockopt(socket, SOL_SOCKET,SO_REUSEADDR, (char *)&reuse, sizeof(int)) == -1 )
	{
		error("Can't set the reuse option on the socket");
	}
	int c = bind(socket, (struct sockaddr *) &name, sizeof(name));
	if( c== 1)
	{
		error("Can't bind to socket");
	}
}

int open_listener_socket() 
{
	int s = socket(PF_INET, SOCK_STREAM, 0); 
	if (s == -1)
		error("Can't open socket");
	return s; 
}

int say(int socket, char *s)
{
	int result = send(socket, s, strlen(s), 0);
	if(result == -1)
	{
		fprintf(stderr, "%s: %s\n", "Error talking to the client", strerror(errno));
	}
	return result;
}

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; 
}

void handle_shutdown(int sig)
{
	if(listener_d)  close(listener_d);
	fprintf(stderr, "Bye!\n");
	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* do_something(void *a) {
	int i = 0;
	for (i = 0; i < 5; i++) {
		sleep(1);
		puts("Does do!"); 
	}
	return NULL; 
}

#include<pthread.h>
....

pthread_t t;

if (pthread_create(&t, NULL, do_something, NULL) == -1)
{	
	error("Can't create thread t0");
}

pthread_mutex_lock(&beers_lock); 
/// some share varible
....
pthread_mutex_unlock(&beers_lock);