※main.c파일

#include <stdio.h>

#include "square.h"

#define SQUARE(num) (num)*(num)



int main(void) {

	//int result = square(5);    // 5*5;

	//int result = SQUARE(5); // 5*5;

	

	int i = 5;

	int result = square(i++);  // 5*5

	//int result = SQUARE(i++); // result = (i++) * (i++)  = 5 * 6  = 30;

	printf("result : %d\n",result);

	return 0;

}

※square.h파일

#ifndef SQUARE_H

#define SQUARE_H



extern inline int square(int num) {

	return num * num;

}



#endif

'C Programming' 카테고리의 다른 글

main.c(generic list)  (0) 2023.08.28
main.c(리스트 createNode)  (0) 2023.08.28
main.c(리스트)  (0) 2023.08.28
main.c(queue memcpy)  (0) 2023.08.25
main.c(queue malloc)  (0) 2023.08.25

※main.c파일

#include <stdio.h>

#include <stdlib.h>

#include "list.h"



void printInt(const void *pData)

{

	printf("%d",*(int *)pData);

}

void printDouble(const void *pData)

{

	printf("%f",*(double *)pData);

}



int main(void)

{

	List list1,list2;

	initList(&list1,sizeof(int));

	initList(&list2,sizeof(double));

	

	int i;

	i = 4;		insertFirstNode(&list1,&i); //[4]

	i = 3; 	insertFirstNode(&list1,&i); //[3,4]

	i = 1;	 	insertFirstNode(&list1,&i); //[1,3,4]

	

	int j = 1;

	i = 2;		insertNode(&list1, &j, &i);  //[1,2,3,4]

	i = 3; 	deleteNode(&list1,&i); 		//[1,2,4]

	printList(&list1,printInt);

	

	double d;

	d =4.4;		insertFirstNode(&list2,&d); //[4.4]

	d =3.3; 		insertFirstNode(&list2,&d); //[3.3,4.4]

	d =1.1;	 	insertFirstNode(&list2,&d); //[1.1,3.3,4.4]

	

	double f = 1.1;

	d = 2.2;		insertNode(&list2, &f, &d);  //[1.1,2.2,3.3,4.4]

	d = 3.3; 		deleteNode(&list2,&d); 		//[1.1,2.2,4.4]

	printList(&list2,printDouble);

	

	cleanupList(&list1);

	cleanupList(&list2);

	return 0;

}

※list.h파일

#ifndef LIST_H

#define LIST_H



typedef struct node {

	struct node *next;

}Node;



typedef struct list {

	Node *ptr;

	int eleSize;

}List;



void initList(List *pList,int eleSize);

void cleanupList(List *pList);

void printList(const List *pList,void (*print)(const void*)); //임의의 자료를 받아서 출력하는 함수(함수포인터사용)



void insertFirstNode(List *pList, const void *pData); // 첫번째 노드에 데이터 추가

void insertNode(List *pList,const void *pPrevData, const void *pData); // prevdata 뒤의 노드에 데이터 추가

void deleteNode(List *pList, const void *pData);  // 데이터 삭제



#endif

※list.c파일

#include "list.h"

#include <stdlib.h>

#include <assert.h>

#include <stdio.h>

#include <string.h>



void initList(List *pList,int eleSize)

{

	pList -> ptr = malloc(sizeof(Node) /*+eleSize*/); // dummy nodes는 데이터가 필요없으므로 포인터만 남긴다.

	assert(pList->ptr); // 공간이 할당이 되었으면 계속 진행

	pList ->eleSize = eleSize;

	pList -> ptr -> next = NULL;

}

void cleanupList(List *pList)

{

	Node *ptr = pList ->ptr;

	while (ptr){

		Node *tmp = ptr;

		ptr = ptr->next;

		free(tmp);

	}

}



void printList(const List *pList,void (*print)(const void *)) 

{

	Node *ptr = pList->ptr->next;

	printf("[");

	while (ptr) {

		(*print)(ptr+1); // print(ptr+1);

		printf((ptr->next)? ", ":"");

		ptr = ptr->next;

	}

	printf("]\n");

}



void insertFirstNode(List *pList, const void *pData)

{

	Node *p = malloc(sizeof(Node) + pList->eleSize);

	assert(p);

	memcpy(p+1,pData,pList->eleSize);

	p->next = pList->ptr->next;

	pList->ptr->next = p;

}



void insertNode(List *pList, const void *pPrevData, const void *pData)

{

	Node *ptr = pList->ptr->next;

	while (ptr){

		if (memcmp(ptr+1,pPrevData,pList->eleSize) == 0) {

			break;

		}

		ptr = ptr->next;

	}

	if (ptr){

		Node *p = malloc(sizeof(Node)+pList ->eleSize);

		assert(p);

		memcpy(p+1,pData,pList->eleSize);

		p->next = ptr->next;

		ptr->next = p;

	}

}



void deleteNode(List *pList, const void *pData)

{

	Node *ptr = pList->ptr->next;

	Node *ptr2 = pList->ptr; // ptr뒤에서 따라가는 node

	while (ptr){

		if (memcmp(ptr+1,pData,pList->eleSize) == 0){

			break;

		}

		ptr = ptr->next;

		ptr2 = ptr2 ->next;

	}

	if (ptr){

		ptr2->next = ptr->next;

		free(ptr);

	}	

}

'C Programming' 카테고리의 다른 글

square(inline,매크로함수)  (0) 2023.09.11
main.c(리스트 createNode)  (0) 2023.08.28
main.c(리스트)  (0) 2023.08.28
main.c(queue memcpy)  (0) 2023.08.25
main.c(queue malloc)  (0) 2023.08.25

※main.c파일

#include <stdio.h>

#include <stdlib.h>

#include "list.h"



int main(void)

{

	List list;

	initList(&list);

	

	insertFirstNode(&list,4); //[4]

	printList(&list);

	

	insertFirstNode(&list,3); //[3,4]

	printList(&list);

	

	insertFirstNode(&list,1); //[1,3,4]

	printList(&list);

	

	insertNode(&list, 1, 2);  //[1,2,3,4]

	printList(&list);

	

	deleteNode(&list,3); 		//[1,2,4]

	printList(&list);

	

	cleanupList(&list);

	return 0;

}

※list.h파일

#ifndef LIST_H

#define LIST_H



typedef struct node {

	int data;

	struct node *next;

}Node;



typedef struct list {

	Node *ptr;

}List;



void initList(List *pList);

void cleanupList(List *pList);

void printList(const List *pList);



void insertFirstNode(List *pList, int data); // 첫번째 노드에 데이터 추가

void insertNode(List *pList,int prevData, int data); // prevdata 뒤의 노드에 데이터 추가

void deleteNode(List *pList, int data);  // 데이터 삭제



#endif

※list.c파일

#include "list.h"

#include <stdlib.h>

#include <assert.h>

#include <stdio.h>



static Node* createNode(int data, Node *next) // static 전역 함수는 같은 .c파일에서만 쓸 수 있다.

{

	Node *p = malloc(sizeof(Node));

	assert(p);

	p->data = data;

	p->next = next;

	return p;

}



void initList(List *pList)

{

	pList ->ptr = createNode(-1,NULL); // 더미노드에는 아무값이 들어와도 상관x

}

void cleanupList(List *pList)

{

	Node *ptr = pList ->ptr;

	while (ptr){

		Node *tmp = ptr;

		ptr = ptr->next;

		free(tmp);

	}

}



void printList(const List *pList) 

{

	Node *ptr = pList->ptr->next;

	printf("[");

	while (ptr) {

		printf("%d",ptr->data);

		printf((ptr->next)? ", ":"");

		ptr = ptr->next;

	}

	printf("]\n");

}



void insertFirstNode(List *pList, int data)

{

	pList ->ptr ->next = createNode(data,pList->ptr->next);

}



void insertNode(List *pList, int prevData, int data)

{

	Node *ptr = pList->ptr->next;

	while (ptr){

		if (ptr->data == prevData) {

			break;

		}

		ptr = ptr->next;

	}

	if (ptr){

		ptr ->next = createNode(data,ptr->next);

	}

}



void deleteNode(List *pList, int data)

{

	Node *ptr = pList->ptr->next;

	Node *ptr2 = pList->ptr; // ptr뒤에서 따라가는 node

	while (ptr){

		if (ptr->data == data){

			break;

		}

		ptr = ptr->next;

		ptr2 = ptr2 ->next;

	}

	if (ptr){

		ptr2->next = ptr->next;

		free(ptr);

	}	

}

'C Programming' 카테고리의 다른 글

square(inline,매크로함수)  (0) 2023.09.11
main.c(generic list)  (0) 2023.08.28
main.c(리스트)  (0) 2023.08.28
main.c(queue memcpy)  (0) 2023.08.25
main.c(queue malloc)  (0) 2023.08.25

※main.c파일

#include <stdio.h>

#include <stdlib.h>

#include "list.h"



int main(void)

{

	List list;

	initList(&list);

	

	insertFirstNode(&list,4); //[4]

	printList(&list);

	

	insertFirstNode(&list,3); //[3,4]

	printList(&list);

	

	insertFirstNode(&list,1); //[1,3,4]

	printList(&list);

	

	insertNode(&list, 1, 2);  //[1,2,3,4]

	printList(&list);

	

	deleteNode(&list,3); 		//[1,2,4]

	printList(&list);

	

	cleanupList(&list);

	return 0;

}

※list.h파일

#ifndef LIST_H

#define LIST_H



typedef struct node {

	int data;

	struct node *next;

}Node;



typedef struct list {

	Node *ptr;

}List;



void initList(List *pList);

void cleanupList(List *pList);

void printList(const List *pList);



void insertFirstNode(List *pList, int data); // 첫번째 노드에 데이터 추가

void insertNode(List *pList,int prevData, int data); // prevdata 뒤의 노드에 데이터 추가

void deleteNode(List *pList, int data);  // 데이터 삭제



#endif

※list.c파일

#include "list.h"

#include <stdlib.h>

#include <assert.h>

#include <stdio.h>



void initList(List *pList)

{

	pList -> ptr = malloc(sizeof(Node)); // dummy node

	assert(pList->ptr); // 공간이 할당이 되었으면 계속 진행

	pList -> ptr ->data;

	pList -> ptr -> next = NULL;

}

void cleanupList(List *pList)

{

	Node *ptr = pList ->ptr;

	while (ptr){

		Node *tmp = ptr;

		ptr = ptr->next;

		free(tmp);

	}

}



void printList(const List *pList) 

{

	Node *ptr = pList->ptr->next;

	printf("[");

	while (ptr) {

		printf("%d",ptr->data);

		printf((ptr->next)? ", ":"");

		ptr = ptr->next;

	}

	printf("]\n");

}



void insertFirstNode(List *pList, int data)

{

	Node *p = malloc(sizeof(Node));

	assert(p);

	p->data = data;

	p->next = pList->ptr->next;

	pList->ptr->next = p;

}



void insertNode(List *pList, int prevData, int data)

{

	Node *ptr = pList->ptr->next;

	while (ptr){

		if (ptr->data == prevData) {

			break;

		}

		ptr = ptr->next;

	}

	if (ptr){

		Node *p = malloc(sizeof(Node));

		assert(p);

		p->data = data;

		p->next = ptr->next;

		ptr->next = p;

	}

}



void deleteNode(List *pList, int data)

{

	Node *ptr = pList->ptr->next;

	Node *ptr2 = pList->ptr; // ptr뒤에서 따라가는 node

	while (ptr){

		if (ptr->data == data){

			break;

		}

		ptr = ptr->next;

		ptr2 = ptr2 ->next;

	}

	if (ptr){

		ptr2->next = ptr->next;

		free(ptr);

	}	

}

'C Programming' 카테고리의 다른 글

main.c(generic list)  (0) 2023.08.28
main.c(리스트 createNode)  (0) 2023.08.28
main.c(queue memcpy)  (0) 2023.08.25
main.c(queue malloc)  (0) 2023.08.25
main.c(queue 구조체)  (0) 2023.08.25

※main.c파일

#include <stdio.h>

#include "queue.h"



int main(void)

{

	Queue s1, s2;

	initQueue(&s1,10,sizeof(int));

	initQueue(&s2,100,sizeof(double));

	

	int i;

	i = 100;	push(&s1,&i);  

	i = 200;	push(&s1,&i);

	

	int re1;

	pop(&s1,&re1);	printf("s1 1st pop() : %d\n", re1);

	i = 300; 	push(&s1,&i);

	pop(&s1,&re1);	printf("s1 2nd pop() : %d\n", re1);

	pop(&s1,&re1);	printf("s1 3rd pop() : %d\n", re1);

	double d;

	d = 1.1; 	push(&s2,&d);

	d = 2.2;	push(&s2,&d);

	

	double re2;

	pop(&s2,&re2); 	printf("s2 1st pop() : %f\n",re2);

	d = 3.3;  push(&s2,&d);

	pop(&s2,&re2);	printf("s2 2nd pop() : %f\n",re2);

	pop(&s2,&re2); 	printf("s2 3rd pop() : %f\n",re2);

	

	cleanupQueue(&s1);

	cleanupQueue(&s2);

	

	return 0;

}

※queue.h파일

#ifndef QUEUE_H

#define QUEUE_H



typedef struct queue {

	void *array;

	int rear;

	int front;

	int size;

	int eleSize;

}Queue;





void initQueue(Queue *s, int size, int eleSize);

void cleanupQueue(Queue *s);



void push(Queue *s,  void *pData);

void pop(Queue *s,  void *pData);

#endif

※queue.c파일

#include <stdlib.h>

#include <stdio.h>

#include <assert.h>

#include <string.h> 

#include "queue.h"



void initQueue(Queue *s, int size, int eleSize)  

{

	s->array = malloc(eleSize*size);

	assert(s->array);

	s->eleSize = eleSize; 

	s->size = size;

	s->rear = 0;

	s->front = 0;

}



void cleanupQueue(Queue *s) 

{

	free(s->array);

}



void push(Queue *s,void *pData)

{

	assert(s->rear != s->size);

	//memcpy(&s->array[s->tos],pData,s->eleSize);  // void 포인터는 역참조할 때 타입캐스팅을 하고 참조해야한다.

	memcpy((unsigned char *)s->array + s->eleSize * s->rear, pData,s->eleSize);

	++s->rear;

}



void pop(Queue *s, void *pData)

{

	assert(s->front < s->rear);

	int index = s->front;

	++s->front;

	//memcpy(pData,&s->array[s->tos],s->eleSize);

	memcpy(pData,(unsigned char *)s->array + s->eleSize * index, s->eleSize);

}

'C Programming' 카테고리의 다른 글

main.c(리스트 createNode)  (0) 2023.08.28
main.c(리스트)  (0) 2023.08.28
main.c(queue malloc)  (0) 2023.08.25
main.c(queue 구조체)  (0) 2023.08.25
main.c(queue)  (0) 2023.08.25

※main.c파일

#include <stdio.h>

#include "queue.h"



int main(void)

{

	Queue s1, s2;

	initQueue(&s1,10);

	initQueue(&s2,100);

	

	push(&s1,100);  //구조체 자료는 인자를 전달할 때 오버헤드를 줄이기 위해 포인터를 쓴다.

	push(&s1,200);

	printf("s1 1st pop() : %d\n",pop(&s1));

	push(&s1,300);

	printf("s1 2nd pop() : %d\n",pop(&s1));

	printf("s1 3rd pop() : %d\n",pop(&s1));

	

	push(&s2,900);

	push(&s2,800);

	printf("s2 1st pop() : %d\n",pop(&s2));

	push(&s2,700);

	printf("s2 2nd pop() : %d\n",pop(&s2));

	printf("s2 3rd pop() : %d\n",pop(&s2));

	

	cleanupQueue(&s1);

	cleanupQueue(&s2);

	

	return 0;

}

※queue.h파일

#ifndef QUEUE_H

#define QUEUE_H



typedef struct queue {

	int *array;

	int rear;

	int front;

	int size;

}Queue;





void initQueue(Queue *s, int size);

void cleanupQueue(Queue *s);

void push(Queue *s, int data);

int pop(Queue *s);





#endif

※queue.c파일

#include <stdlib.h>

#include <stdio.h>

#include <assert.h> 

#include "queue.h"



void initQueue(Queue *s, int size)  

{

	s->array = malloc(sizeof(int)*size);

	assert(s->array /*!= NULL*/); 

	s->size = size;

	s->rear = 0;

	s->front = 0;

}



void cleanupQueue(Queue *s) 

{

	free(s->array);

}



void push(Queue *s, int data)

{

	assert(s->rear != s->size);

	s->array[s->rear] = data;

	++s->rear;

}



int pop(Queue *s)

{

	assert(s->front < s->rear);

	int index = s->front;

	++s->front;

	return s->array[index];

}

'C Programming' 카테고리의 다른 글

main.c(리스트)  (0) 2023.08.28
main.c(queue memcpy)  (0) 2023.08.25
main.c(queue 구조체)  (0) 2023.08.25
main.c(queue)  (0) 2023.08.25
main.c(스택-메모리함수사용)  (0) 2023.08.25

+ Recent posts