[자료구조] C언어 - 스택(stack) 구현 - 객체지향

- C언어로 구현한 스택(stack) 코드이다. 완벽하진 않지만 c에서 객체지향 개념을 넣을 수 있는 기본 베이스는 마련해둔 코드이다.

 

- 글 말고 github으로 보려면 여기를 누르면 된다.

 

- 영어를 잘 못하지만 주석을 영어로 작성했으므로 틀린 표현이 많을 수 있다. (댓글로 알려줘요 ㅠ)

 

- 이하 코드에서 사용된 node.h, list.h, list.c는 '[자료구조] C언어 - 이중 연결 리스트(doubly linked list) 구현 - 객체지향' 글에서 구현한 코드들이다. 위 github에서 보거나, 여기를 눌러 해당 글에서 확인하면 된다.

 

 

0. 사용예시

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

int main(int argc, char* argv[]) {
	stack_t* s = create_stack();

	s->op->push(s, "aa");
	s->op->push(s, "bb");
	s->op->push(s, "cc");
	s->op->push(s, "dd");
	printf("size : %d\n", s->op->get_size(s));

	printf("%s\n", (char*)(s->op->peek(s)));
	printf("%s\n", (char*)(s->op->peek(s)));
	printf("size : %d\n", s->op->get_size(s));
	
	printf("%s\n", (char*)(s->op->pop(s)));
	printf("%s\n", (char*)(s->op->pop(s)));
	printf("%s\n", (char*)(s->op->pop(s)));
	printf("%s\n", (char*)(s->op->pop(s)));
	printf("size : %d\n", s->op->get_size(s));
	//printf("%s\n", (char*)(s->op->pop(s)));
	
	s->op->destroy(s);
}

 

1. stack.h

/**
* Stack Header
* OOP Style
* made by nahwasa
*/

#ifndef STACK_H_NAHWASA
#define STACK_H_NAHWASA

#include"node.h"
#include"list.h"

typedef struct struct_stack{
	list_t* list;
	struct stack_operations* op;
} stack_t;


struct stack_operations {
	void (*destroy)(stack_t* s);
	void (*push)(stack_t* s, void* data);
	void* (*pop)(stack_t* s);
	void* (*peek)(stack_t* s);
	int (*is_empty)(stack_t* s);
	int (*get_size)(stack_t* s);
};

extern stack_t* create_stack();


#endif

 

2. stack.c

/**
* Stack (using linked list)
* OOP Style
* made by nahwasa
*/

#include<stdio.h>
#include<stdlib.h>
#include"stack.h"

static void destroy(stack_t* s);
static void push(stack_t* s, void* data);
static void* pop(stack_t* s);
static void* peek(stack_t* s);
static int is_empty(stack_t* s);
static int get_size(stack_t* s);

static struct stack_operations op =
	{
		.push = push,
		.destroy = destroy,
		.pop = pop,
		.peek = peek,
		.is_empty = is_empty,
		.get_size = get_size
	};

/*
* create stack object and return
*/
stack_t* create_stack()
{
	stack_t* s = (stack_t*)malloc(sizeof(stack_t*));

	s->list = create_list();
	s->op = &op;
	
	return s;
}

/*
* release memory
*/
static void destroy(stack_t* s)
{
	s->list->op->destroy(s->list);
	s->op = NULL;
	free(s);
	s = NULL;
}

/*
* put one data to stack
*/
static void push(stack_t* s, void* data)
{
	s->list->op->insert_to_head(s->list, data);
}

/*
* get one data from stack and delete it
*/
static void* pop(stack_t* s)
{
	if ( s->list->op->is_empty(s->list) )
		return NULL;
	
	node_t* node = s->list->op->get_head_node(s->list);
	s->list->op->delete_head_node(s->list);
	
	return node->data;
}

/*
* get one data from stack
*/
static void* peek(stack_t* s)
{
	if ( s->list->op->is_empty(s->list) )
		return NULL;
	
	node_t* node = s->list->op->get_head_node(s->list);
	
	return node->data;
}

static int is_empty(stack_t* s)
{
	if (!s->list->op->get_size(s->list))
		return 1;
	else
		return 0;
}

static int get_size(stack_t* s)
{
	return s->list->op->get_size(s->list);
}