Chapter 12 Structure and ADTs 프로그래밍 기초와 실습. Chapter 12 Structure and ADTs 2 Contents Declaring Structures Accessing a Member Operator Precedence

Chapter 12

Structure and ADTs

프로그래밍 기초와 실습

Chapter 12 Structure and ADTs 2

Contents

Declaring Structures

Accessing a Member

Operator Precedence and Associativity Structures, Functions, and Assignment

Problem Solving : Student Records

Initialization of Structures

The Use of typedef


Self-Referential Structures Linear Linked Lists Dynamic Allocation List Operations

Contents



Array 와 structure 의 차이점

– array

• Array 의 모든 element 는 같은 type 이여야 한다 .

• Index 를 사용하여 각 element 를 access 한다 .

– structure

• 다른 type 의 element 로 구성 될 수 있다 .

• 각 element 는 name 을 갖는다 .

• Name 에 의해 각 element 를 access 한다 .



struct declaration– Collection of members(/elements)

[Ex] struct { /* 3 elements 로 구성된 structure */ int number; char name [20] ; int on_hand;} part1;

{ } 의 형태로 variable ‘part1’ 을 선언한다 .Part1 은 int, char array, int type 의

3 member 를 포함하는 struct type 의 variable



structure tag

- 정의 되는 특정 structure 를 지정하기 위한 name.

- 한 번 structure tag 인 part 가 정의되면 , 이제 tag 를 사용하여 같은 structure type 으로 선언할 수 있다 .

[Ex] struct part { int number; char name [20] ; int on_hand;};

[Ex] struct part part1, part2 ; /* correct declaration */part part1, part2; /* wrong declaration */

struct tag:생략 가능하지만 생략 시

이 후에 선언 불 가능



structure tag 와 변수 동시 선언가능– structure tag 를 이용하여 선언된 변수는 같은 structure

type[Ex] struct part {

int number; char name [20] ; int on_hand;} part1, part2;

struct part part3;

part1, part2, part3 는 모두 compatible



Initializing Struct variables

[Ex] struct student { int number; char name [20] ; int score;

} part1 = {1, “handong”, 95}, part2;

part1

part1.number part1.name part1.score

1 handong 95



Compatible structure– 같은 type 의 structure variable 이면 서로 assign 가능

– compatible types 의 조건• Structure 정의와 동시에 선언되는 모든 variables

• 같은 type 의 structure 즉 같은 tag 에 의해 선언된 모든 variables.

[Ex] part1 = part2; /* legal operation */

part2 의 모든 member 의 values들은 part1 의 각 member 로 copy 된다 .

[Ex] struct part { int number; char name [20] ; int on_hand;

} part1, part2;

[Ex] struct part part3, part4;

/* part1, part2

part3, part4 모두 compatible

types */



Compatible structure

– compatible type 이 아닐 경우 =, ==, != 불가능

[Ex] struct { struct { int x, y; int x, y; } data1; } data2;

data1 = data2; /* illegal operation */

/* 같은 member 로 구성되어도 각 기 정의하여 선언 한다면 서로 다른 type 으로 not compatible */



[Ex] struct { int a[10];} a1, a2; a1 = a2; /* legal */

int a1[10], int a2[10]={0}; a1=a2; /* illegal*/

[Ex] struct {struct { int number;

char name[20]; int on_hand;

} part1;

struct { int number;

char name[20]; int on_hand; } part2 ;

part1 and part2 are notcompatible



[Ex] struct { int number; char name [20] ; int on_hand;

} part1;

Memory Allocation

– Structure 로 선언된 데이터 type 은 각 member 들이 메모리 내에 순차적으로 할당된다 .

– part1 의 base address 가 200 이고 , integer 의 size 가 4bytes 라고 가정하면 , 오른쪽 그림과 같이 메모리가 할당됨 .

200

204:

222

223

224

228

part1.number

part1.name[0]

part1.name[18]part1.name[19]part1.on_hand


Accessing a Member struct member operator ‘.’

– Structure 의 각 member 를 access 하기 위해 ‘ .’ 를 사용한다 .[Ex] struct {

int number; char name[20]; int on_hand; } part1={1, “Monitor”, 10};

printf (“Part number : %d\n”, part1.number);printf (“Part name : %s\n”, part1.name);printf (“Quantity on hand : %d\n”, part1.on_hand);

part1

part1.number part1.name part1.on_hand

1 Monitor 10

Part number : 1Part name : MonitorQuantity on hand : 10


Accessing a Member

member operation

[Ex] struct { int number; char name[20]; int on_hand; } part1;

scanf (“%d”, &part1.on_hand); /* reading using scanf() */scanf(“%s”, part1.name); part1.number = 258; /* assignment */part1.on_hand++; /* increment */


Accessing a Member

structure pointer

[Ex] struct complex { double re; double im;

};

struct complex c1, c2, *a=&c1, *b=&c2; /* a 는 structure ‘c1’ 을 refer, b 는 ‘ c2’ 을 refer*/

a->re = b->re + 2 ; /* c1.re = c2.re + 2; 와 동일 */ b->im = a->im – 3; /* c2.im = c1.im – 3; 와 동일 */

printf (“value ; %f\n ”, a->im);


Accessing a Member

[Ex] struct shape { int x, y ; char name[10] ;

};

struct shape s, *p = &s;scanf (“%d %d %s”, &p->x , &p->y, p->name ) ;

/* operator ‘->’ 는 ‘ &’ 를 우선한다 . &p->x &(p->x)*/

s.x = p->x * 2; /* p->x = s.x *2; 와 동일 */p->y = s.y % 5;

printf (“%d %d %s\n”, p->x , p->y, p->name ) ;

12 23 handong24 3 handong


Accessing a Member

[Ex] struct shape { int x, y ; char name[10] ;

};

struct shape s, *p = &s;scanf (“%d %d %s”, &(*p).x , &(*p).y, (*p).name ) ;

/* operator ‘.’ 는 ‘ &’ 를 우선한다 . &p->x &(*p).x*/

s.x = (*p).x * 2; /* p->x = s.x *2; 와 동일 */(*p).y = s.y % 5;

printf (“%d %d %s\n”, (*p).x , (*p). y, (*p). name ) ;

12 23 handong24 3 handong

괄호를 생략할경우 ‘ .’ 가 우선선위가 높으므로p.y 를 먼저 수행 . p 는 pointer 이므로 error 발생


Precedence and Associativity of Operators

( ) [ ] . -> ++(postfix) --(postfix) left to right

++(prefix) --(prefix) ! ~ sizeof(type)+(unary) -(unary) &(address) *(dereference)

right to left

* / % left to right

+ - left to right

<< >> left to right

< <= > >= left to right

== != left to right

& left to right

^ left to right

| left to right

&& left to right

|| left to right

? : right to left

= += -= *= /= %= >>= <<= &= ^= |= right to left


Structures, Functions, and Assignment

Structures as Argument– call-by-value 로 struct 가 copy 되어 사용 된다 .

[Ex] struct card { int pips; char suit;}c1 = {5, ’d’};

: assign_values(c1);

printf(“%d %c”, c1.pips, c1.suit); :

void assign_values(struct card c) { c.pips = 1; c.suit = ‘c’;}

parameter 를 struct card c 로사용할 경우 struct 가 memory 에

복사하게 되므로 call-by-value 가 되어 return 후 변경된 값이 유지 되지 않는다 .

5 d



Struct pointer 사용– call-by-reference 로 struct 의 address 를 전달한다 .

[Ex] struct card { int pips; char suit;}c1 = {5, ’d’};

: assign_values(&c1);

printf(“%d %c”, c1.pips, c1.suit); :

void assign_values(struct card *c) { c->pips = 1; c->suit = ‘c’;}

parameter 를 struct card *c 로사용할 경우 struct 의 address 가

전달되어 call-by-reference 가 되므로 return 후 변경된 값이 유지 된다 .

1 c


Structure 사용

5

d 5

d

main() assign_values()

Structure 의 copy

X 1

X c

Structure Pointer사용

5

d

main()

Address 의 copy

같은 structure의 point X 1

X c

assign_values()


Call -by-Value Call -by-Reference



Structures Pointer 사용[Ex] struct card {

int pips; char suit;

};

void assign_values(struct card *c_ptr, int p, char s) { c_ptr -> pips = p;

c_ptr -> suit = s; }

void extract_values(struct card *c_ptr, int *p_ptr, char *s_ptr) { *p_ptr = c_ptr -> pips; *s_ptr = c_ptr -> suit;

}



[Ex] void prn_values(struct card *c_ptr) { int p; char s; char *suit_name; extract_values(c_ptr, &p, &s); switch(s) { case ‘c’ :

suit_name = “clubs”; break; case ‘d’ :

suit_name = “diamonds”; break; case ‘h’ :

suit_name = “hears”; break; case ‘s’ :

suit_name = “spades”; break; default :

suit_name = “error”; } printf(“card: %d of %s \n”, p, suit_name);}



[Ex] int main(void) { int i; struct card deck[52];

for( i = 0; i < 13; i++) {assign_values(deck + i, i + 1, ‘c’ );assign_values(deck + i + 13, i + 1, ‘d’ );assign_values(deck + i + 26, i + 1, ‘h’ );assign_values(deck + i + 39, i + 1, ‘s’ );

}

for( i = 0; i < 13; i++) /* print out the hearts */prn_values(deck + i + 26);

return 0;}

card : 1 of heartscard : 2 of hearts :card : 13 of hearts

&deck[ i+13] 와 같은 표현으로struct 의 address 를 전달



Nested Structure

[Ex] struct person_name { char first[10]; char middle_initial; char last[10];};

struct student { struct person_name name ; int id, age; char sex; } student1, student2;

student1

student1.name.middle_initial student1.id

student1.name.first

student1.name.laststudent1.age student1.sex



Nested Structure– nested member name 으로 access 가능

– 정의된 member ‘name’ 으로 access 가능

[Ex] strcpy ( student1.name.first, “Fred”) ;strcpy ( student1.name.last, “Gordon”) ;

[Ex]display_name ( student1.name); /* 하나의 argument 로 사용 가능 */

struct person_name new_name={“Young”,’s’, “Kim”} ;student1.name = new_name ; /* 같은 struct 로 assignment 가능 */



[Ex]

void display_name ( struct person_name name) { printf(“name : %s %c. %s\n”,

name.first, name.middle_initial, name.last);}

void display(struct student s) {printf(“id : %d\n”, s.id);display_name(s.name);printf(“age : %d\n”, s.age);printf(“gender : %c”, s.gender);

}



Arrays of Structure[Ex] struct part int number; char name[10]; int on_hand; } inventory[100];

inventory[0]

inventory[0].number inventory[0].on_hand

1 Monitor 10

inventory[1]

inventory[1].number inventory[1].on_hand

5 Memory 53 ………

inventory[0].name

inventory[1].name



[Ex] #define CLASS_SIZE 50#define NCOURSES 10

struct student { char *last_name; int student_id;

char grade;};

struct date { short day; char month[10]; short year;};

struct personal { char name[20]; struct date birthday;};



struct student_data { struct personal p; int student_id; char grade[NCOURSES];};

[Ex] /* struct date type 의 variable 에 data 를 입력받음 */

void read_date(struct date *d) { printf(“Enter day(int) month(string) year(int) : “); scanf(“%hd%s%hd”, &d->day, d->month, &d->year);}

:struct student_data temp;read_date(&temp.p.birthday);

struct personalstruct date

&(d->day) 와 같은 표현



[Ex] /* student_data type 의 member 중 char[ ] grade 를 입력받음 */

void read_grades(char g[ ]) { int i; printf(“Enter %d grades: “, NCOURSES); for( i = 0; i < NCOURSES; ++i)

scanf(“ %c”, &g[ i]);}

:

read_grades(temp.grade);

char[ ] type:array name 은 array 의 base address 를

나타내는 char pointer 로call-by-reference 가 된다 .



[Ex] /* struct student_data type variable 의 information 을 struct student 의 variable 에 convert */

#define C_PROGRAMMING 0#define UNIX 1

void extract (struct student_data *s_data, int n, struct student *undergrad) {

undergrad -> student_id = s_data -> student_id; undergrad -> last_name = s_data -> p.name; undergrad -> grade = s_data -> grade[n];}

: struct student_data temp;

struct student student[100];extract(&temp, C_PROGRAMMING, &student[0]);



Initializing an array of Structures

[Ex] struct dialing_code { char *country; int code;

} ;

const struct dialing_code country_codes[ ] = { {“Argentina”, 54},

{“Bangladesh”, 880}, {“Korea”, 82},

: } ;

Array size 는 compiler 에 의해 자동 삽입



Initializing a nested Structures

struct student st = { {"Kim", 's', "Handong"}, 197001, 25, 'T'

};

Array size 는 compiler 에 의해 자동 삽입

[Ex] struct person_name { char first[10]; char middle_initial; char last[10];};

struct student { struct person_name name ; int id

int age; char sex; };


The Use of typedef

The use of typedef– data type 의 name 을 재 정의 하기 위해 사용– readability 의 증가

[Ex] #define N 3 /* size of all vectors and matrices */

typedef double scalar;typedef scalar vector[N];typedef scalar matrix[N][N];

typedef vector maxrix[N]와 같은 표현

double 의 1 차원 array type 의 vector 선언

[Ex] void add(vector x, vector y, vector z) { int i; for( i = 0 ; i < N; ++i)

x[ i ] = y [ i ] + z [ i ];}


The Use of typedef

[Ex] scalar dot_product(vector x, vector y) { int i; scalar sum = 0.0;

for(i = 0; i < N; ++i) sum += x[ i] * y [ i];

return sum;}

void multiply(matrix a, matrix b, matrix c) { int i, j, k;

for(i = 0; i < N; ++i) for(j = 0; j< N; ++j ) { a[ i][ j] = 0.0; for( k = 0; k < N; ++k) a[ i][ j] += b[ i][ k] * c[ k][ j];}

}

double sum=0.0; 과 동일

double a[N][N] 과 동일


typedef 를 사용 , struct type 을 새로운 type 으로 선언[Ex] typedef struct {

int number; char name[20]; int on_hand;

} part;

part part1, part2

The Use of typedef

새로운 type part 가 정의

[Ex] struct part { int number; char name[20]; int on_hand;

};

typedef struct part part;

새로운 type part 가 정의


The Use of typedef

[Ex] typedef struct part part;

struct part p1;part *p2 = &p1;

:display1(&p1);display2(&p1);

display1(p2);display2(p2);

void display1 (struct part* p) { printf(“%d, %s, %d”, p->number, p->name, p->on_hand);}

void display2 (part* p) { printf(“%d, %s, %d”, p->number, p->name, p->on_hand);}


Self-Referential Structures– struct member 중에 같은 struct type 을 reference

하는 pointer 를 가지고 있음

– compatible, 즉 같은 type 의 structure 를 link 하기 위해 사용

[Ex] struct list { int data; struct list *next;

}

Self-Referential Structures

next 를 통해서 같은 type 의 다른 structure 와 연속적으로 link 됨

data next


[Ex] struct list a, b, c;

a.data = 1;b.data = 2;c.data = 3;a.next = b.next = c.next = NULL; /* Point nothing */


NULL1

a

NULL2

b

NULL3

c

data next data next data next


[Ex] a.next = &b;

b.next = &c;

printf(“%d\n”, a.next -> data); /* b.data */

printf(“%d\n”, a.next -> next -> data ); /* c.data */


1

a

2

b

NULL3

c

data next data next data next

2 3


Linear Linked List– 여러 개의 structure 가 연속적으로 link

– structure 는 data part 와 address part 로 구성된다 .

– Address part 는 같은 type 의 structure 를 point 하는 member 로 구성된다 .

– head 는 첫번째 Element 를 point

– 각각의 Element 는 다음의 Element 를 point

– 마지막 Element 의 address part 는 NULL

– Element 는 dynamic allocation 에 의해 생성된다 .

Linear Linked Lists

NULL

headdata data dataaddres

saddres

saddres

s


Linear Linked Lists

[Ex] /* filename : list.h */

#include <stdio.h>

typedef char DATA;

struct linked_list { DATA d; struct linked_list *next;}

typedef struct linked_list ELEMENT; typedef ELEMENT * LINK;

stdio.h 에서 NULL 을 define

linked list 를 구현하기 위한type 을 정의하고 있는head file ‘list.h’ 작성


Dynamic Allocation

Creates Element list

Linear Linked Lists

[Ex] LINK head;head = (LINK)malloc(sizeof(ELEMENT));/* head 는 할당된 ELEMENT type 의 struct 를 point */

system 으로부터 ELEMENT type 의 struct 를 저장하기 위한 memory 할당

[Ex] LINK head;head = (LINK)malloc(sizeof(ELEMENT));

head -> d = ‘n’; /* data part 에 data 입력 */head -> next = NULL; /* address part 를 초기화 */

‘n’ NULL

head


Linear Linked Lists

[Ex] head -> next =(LINK) malloc(sizeof(ELEMENT));head -> next -> d = ‘e’;head -> next -> next = NULL;

‘n’

head

‘e’ NULL

[Ex] head -> next -> next = (LINK)malloc(sizeof(ELEMENT));head -> next -> next -> d = ‘w’;head -> next -> next -> next = NULL;

‘e’

head

‘w’ NULL‘n’

New element 의 생성 및 list 에 추가


List Operations

[Ex] /* List creation by recursion */

#include “list.h”

LINK string_to_list(char s[ ]) { LINK head;

if(s[ 0] == ‘\0’) /* base case */return NULL;

else {head = (LINK)malloc(sizeof(ELEMENT));head -> d = s [0];head -> next = string_to_list[s+1];return head;

}}

다음 Element 의 address 또는NULL 을 return

String(‘s’) 을 입력 받아char 를 data 로 하는

linked list 를 생성하는 function


List Operations[Ex] /* List creation by iteration */


LINK string_to_list(char s[ ]) { LINK head, temp; int i=0;

if(s[ 0] == ‘\0’) return NULL;

head = (LINK)malloc(sizeof(ELEMENT)); head -> d = s[ 0]; head -> next = NULL; temp = head;

while(s[++i] != ‘\0’) {temp -> next = (LINK)malloc(sizeof(ELEMENT));temp = temp -> next;temp -> d = s [ i];temp -> next = NULL;

} return head;}

String 을 입력 받아char 를 data 로 하는

linked list 를 생성하는 function


Counting

Counting and Lookup

[Ex] /* count the elements in a list recursively */


int count(LINK head) {

if(head == NULL) /* base case */return 0;

elsereturn ( 1 + count(head->next) );

}


Counting and Lookup

[Ex] /* count the elements in a list by iteration */


int count(LINK head) {

LINK temp = head; int cnt = 0; while(temp != NULL) {

cnt++; temp = temp -> next } return cnt;}


Lookup

Counting and Lookup

[Ex] /* Lookup c in the list pointed to by head (recursion)*/


LINK lookup(DATA c, LINK head) {

if(head == NULL) /* 없는 경우 */return NULL;

else if( c == head -> d) /* 찾은 경우 */ return head;

else /* 그 다음 element 의 search */return (lookup(c, head-> next));

}


Counting and Lookup

[Ex] /* Lookup c in the list pointed to by head (iteration)*/


LINK lookup(DATA c, LINK head) {

LINK temp = head;

while(temp != NULL) {if( c == temp -> d) return temp;temp = temp -> next;

} return NULL;}


Insertion

– before insertion

– after insertion

Insertion and Deletion

[Ex] #include “list.h”void insert(LINK p1, LINK q) { /* p1 뒤에 q 를 insert */ q -> next = p1 -> next; p1 -> next = q;}

B NULL

p1C NULLA

q

B

p1C NULLA

q


Deletion

– before deletion

– after deletion


[Ex] #include “list.h”void delete(LINK p1, LINK q) { /* p1 뒤의 q 를 delete */ p1 -> next = q -> next; free(q);}

Bp1

C NULLA

q

Bp1

C NULLA

q

System 이 memory 를 사용할 수 있도록 q 가 reference 하는 부분을 해제시킴

즉 그 영역은 다시 free 가 되어 다른 program 에서 그 영역의 사용 가능

free



[Ex] /* Recursive deletion of a list */


void delete_list(LINK head) {

if(head != NULL) {delete_list(head -> next);free(head);

}} List 의 모든 element 삭제



[Ex] /* Iterative deletion of a list */


void delete_list(LINK head) {

LINK temp;

if(head != NULL) {temp = head;head = head -> next;free(temp);

}}

List 의 모든 element 삭제


Displaying list

[Ex] /* Display all elements in a list */


void display(LINK head) {

LINK temp = head;

while(temp != null) {printf(“ELEMENT (at %p)”, temp);

printf(“\tDATA : %c”, temp -> d);printf(“\tnext : %p\n”, temp -> nexttemp = temp -> next;

}}

List 의 모든 element 를 출력


[Ex] /* Sample main( ) */


LINK string_to_list(char[ ] s);void display(LINK head);

:

int main(void) {

char s[10] = "Handong"; LINK head;

head = string_to_list(s); display(head);}

ELEMENT (at 20a78) DATA : H next : 20a88ELEMENT (at 20a88) DATA : a next : 20a98ELEMENT (at 20a98) DATA : n next : 20aa8ELEMENT (at 20aa8) DATA : d next : 20ab8ELEMENT (at 20ab8) DATA : o next : 20ac8ELEMENT (at 20ac8) DATA : n next : 20ad8ELEMENT (at 20ad8) DATA : g next : 0

string 으로 linked list 를 생성하고list 의 모든 element 를

출력하는 program

Displaying list

수고하셨습니다 .

Structure and ADTs

Documents

Chapter 12 Structure and ADTs 프로그래밍 기초와 실습. Chapter 12 Structure and ADTs 2 Contents Declaring Structures Accessing a Member Operator Precedence