CHAPTER 9
PROGRAM STRUCTURE
Our previous programs have had a simple structure.
This chapter deals with more complex program
organizations.
We finish up our description of variables local
to particular functions
and introduce variables accessible by any function.
While discussing variables, we present the storage
classes that control their lifetime, location, and
visibility.
We then show how header files simplify accessing
variables and functions defined in other files,
and how we can have variables and functions accessible only
within a single file.
This chapter concludes with a case study: an initial
implementation of a set data type.
Jump to:
[Previous Chapter |
Next Chapter]
- LOCAL VARIABLES
- Concise Variable Declarations
- Initializing Local Variables
- Declaring Variables within Blocks
- GLOBAL VARIABLES
- STORAGE CLASSES
- The Storage Class auto
- The Storage Class register
- The Storage Class static
- The Storage Class extern
- TYPE QUALIFIERS
- USER-DEFINED TYPES
- HEADER FILES
- PRIVATE VARIABLES AND FUNCTIONS
- Implementing Queues
- Implementing Our Bus Stop Simulator
- CASE STUDY: ABSTRACT DATA TYPES
- Implementing Sets
- The Set Type and Its Operations
- Using Sets
Objectives
- ���α� ��� ������ �߿伺�� �ν��Ѵ�.
- Function�� ���̿� �����Ǿ�� �� ���� ǥ���� ���� ���� ���� ������ ������.
- ������ ���� ���� ����� ������ �ν��Ѵ�.
- �ϳ��� �� ���ѵ� function �� global variable
���Ǹ� ���� static keyword ������ ������.
- Interface, Package, Abstraction, Implementor, client ���� ������ �����Ѵ�.
- C�� header file�� �̿��� interface �ۼ����� �����Ѵ�.
- ��ȭ(Abstraction)�� ��������(Information Hiding)�� ������ �����Ѵ�.
- C program�� function���� �������� �����ȴ�.
- C function���� ��� ���� file�� ���� �ʿ�� ����. ���� ���� file�� ����Ǿ� ���� ���������� compile�ǰ�
object file���� link�Ǿ� �ϳ��� executable file�� ���� �� �ִ�.
- ������ ���α��� �Ϻημ� ������ file �Ǵ� file�鿡
����Ǵ� ���α� �κе��� ��� (module)�̶� �Ѵ�.
- �� ����� ���� ������ �ִ� ����� �����ϴ� function��� �����Ǿ�� �Ѵ�.
- �����ϰ� ����� ������ ��� ���ش� top-down design�� �⺻�̴�.
- ���α��� ���� �����ϴ� �۾��� Ư���� ����Ʈ���� �������� ����� ������ �ʿ�� �Ѵ�.
- ��ġ ���, ���, ���Ƚ�, ���� ó�� ���� ����
���� ���α����� ���ߵǾ� ���ȴ�.
- �̷��� ���α� �ڵ���� math library, statistics
library, graphics library, image processing library ��� ����
library�� �����Ǹ� �� library�� �����ϴ� �ڵ���� ��� package��
�Ѵ�.
- Package�� library function���� �̿��� abstraction ����� �����Ѵ�.
- Library function �����ڸ� implementor��
�ϰ� ����ڸ� client�� �Ѵ�.
- Client�� package�� ����ϱ� ���ؼ���
�� package�� ���ǵ� interface�� �̿��Ͽ��� �Ѵ�.
- C function���� interface�� ����
header file�� �̿��Ͽ� �����ϰ� function ����� �����ϴ� program��
source code �Ǵ� object code�� compile�Ͽ� library ������ binary
code�� �����ȴ�.
- Ư�� ���� �о߿� ���� ���Ǵ� function���� ������ Framework��
�Ѵ�.
- �Ը� ũ�� ������ ���α� ���� �� �����ϸ�
���� framework�� �̿��Ѵ�. (Windows programming ��) ���� ����
framework�� ������ ���� ������ ���� �����Ѵ�.
- ���α� ���� �� framework�� �����ϴ� �����
Ȱ���Ͽ� ������ ���α��� ������ ����. (Bottom-up implementation)
��)
main module: main function�� �����ϴ� ���α��� �⺻ ���
graphics module: graphics ���� function��� ������ ���α� file��
communication module, text processing module, ...
main.c
----------------------
#include "module1.h"
#include "module2.h"
main()
{
ProcA();
ProcB();
}
module1.h module2.h
-------------- ---------------
void ProcA(void); void ProcB(void);
module1.c module2.c
-------------- ---------------
#include "module1.h" #include "module2.h"
void ProcA(void) void ProcB(void)
{ {
. . . . . .
} }
������ ��� ���� (������ ��ġ�� ����, scope), ����
- Function ������� ���� ���
- �� file �������� ���� ���
- ���� file ������ ���� ���� ���
Global variable (���� ����):
Function �ܺο��� ���ǵǾ� �� �� ��� function���� ��� ����.
���α� ���� �� ��� ���� (�� �Ҵ�� ���α� ���� �ñ���
��� ����)
- Global variable�� ������ ����� ���α��� �����ϱ� ��ư� �����.
- ������ �� global variable�� ����� �����Ͽ� module���� �������� ũ�� �Ѵ�.
Local variable (���� ����):
Function ���� �Ǵ� block ������ ���ǵǾ� �� function �Ǵ� block
�������� ��� ����. Function ������ ������ �ڵ� �Ҹ�.
��)
int g; // global variable g declaration
void func(void)
{
int i; // local variable i ����
. . .
}
Storage class - �ڷᰡ �����Ǿ�� �� �Ⱓ �� ���� ����
- Storage class ���� ����: storage_class data_type variable_list;
Storage class ����
- auto: automatic, default storage class (Ư���� ���ǰ�
������ �ڵ����� auto�� ����)
- Function ���� �Ǵ� block ������ ���ǵǾ� �� function �Ǵ�
block �������� ��� ������ local variable. Function ������ ������
�ڵ� �Ҹ� (��� ��Ҹ� ���� ����)
- static: ��� ��Ҹ� ������ �Ҵ�
- static internal: function ����� ����, ������� ��� ����
- static global: ���ǰ� ���Ե� file �������� ��� ����
- extern: external, �ٸ� file���� ���ǵ� global variable ����
- register: ������ �� CPU register �̿� (���� ������
�����ϴ�). ��ǻ�� ������ ���� ��� ����
��)
static int g; // ���� g�� �� ������ ����� file �������� ��� ����
float f; // ���� f�� �ٸ� file������ ���� ����.
// ��, extern float f; �� ������ �־�� �Ѵ�.
void func1(void) // Function func1�� �ٸ� file������ ȣ�� ����.
// ��, function prototype�� ������ �־�� �Ѵ�.
{
static int i; // ���� i�� func1 ������ ������ ���� ����.
int d; // ���� d�� func1 ������ ������ ���̼Ҹ�
. . .
}
static func2(void) // Function func2�� �ٸ� file���� ȣ�� �Ұ���
{
. . .
}
������ �ʱ�ȭ (Variable Initialization)
������ ����ϱ� ���� �ݵ�� �ʱ�ȭ�Ͽ��� �Ѵ�.
�ʱ�ȭ���� ���� auto�� register ������ ������ �Ҵ�� �� ����� ������ ���� ����Ѵ�.
�ʱ�ȭ���� ���� global�� static ������ 0���� compile�� �ʱ�ȭ�ȴ�.
���� �ʱ�ȭ ��)
auto�� register ���� �ʱ�ȭ: [�ڷ��� ������ = ��(expression)]
int a = 10;
char ch = 'A';
int b = a + ch;
global�� static ���� �ʱ�ȭ: [�ڷ��� ������ = ����(numeric expression)]
static int a = 10;
static double d = 3.141592;
int b = 10 * 20;
int c = a * b; // Wrong
int d = getchar(); // Wrong
���� ���� ���� ������ �ڷῡ ���� Ư�� ���� �ο��Ϸ���
��� 1) #define �� ���
#define SUNDAY 0
#define MONDAY 1
#define TUESDAY 2
#define WEDNESDAY 3
#define THURSDAY 4
#define FRIDAY 5
#define SATURDAY 6
��� 2) Enumeration type ���
enum { SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
} ;
enum type�� ���� : enum tag_name { list of elements };
enum variable ���� : enum tag_name list of variables ;
enum tag_name { list of elements } list of variables
;
������ element�� Ư������ �ο��� �� �ְ� Ư�� ���� �ο����� ����
��� ù��° element�� 0�� �����ϰ� ���� element ���� 1 �� ����.
��)
enum MONTH { JAN = 1, FEB, MAR, ..., NOV, DEC };
enum MONTH BirthMonth, SalaryMonth, ... ;
Enumeration type�� ���� �ϳ�, ��, �� �� �ִ� ������ �ڷḦ scalar
type�̶� �Ѵ�. C���� scalar type���� �ڵ������� integer��
ó���ȴ�. ���Ƿ� enum type�� element�鵵 ���꿡 ���� �� �ִ�.
(���� ����� ��DZ� ������ ���ο� ���� assign�� �� ����.)
Type Qualifiers : const, volatile
const : Ư�� ������ ���ó�� ���. ���� ���� �ʱ�ȭ �� �� �� ������ �Ұ���.
��) const int MAXVAL = 100;
#define MAXVAL 100 ���� ���̴�?
���ο� data type�� ���� : typedef
typedef data_structure type_name;
��)
typedef unsigned char BYTE;
BYTE a, b, c;
typedef enum { FALSE, TRUE } bool;
bool x, y, z;
typedef char * string;
typedef enum { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday,
Saturday } WEEK_DAY ;
�ǽ�) ������ ���� ��� ������ ���α��� �ۼ��϶�.
������ �� ���� ���ϱ� �Ǵ� ���⸦ �����Ѵ�. (���ϱ� �Ǵ� ���⸦ ���Ƿ� ����)
��� ��)
����� ������. 23 + 5 ? 28
�¾����ϴ�. �� ���߾��.
����� ������. 35 - 17 ? 20
�ٽ� �� ������. 35 - 17 ? 18
�¾����ϴ�. �� ���߾��.
����� ������. 17 - 20 ? 20
�ٽ� �� ������. 17 - 20 ? 18
�ٽ� �� ������. 17 - 20 ? 0
�ٽ� �� ������. 17 - 20 ? -1
�ٽ� �� ������. 17 - 20 ? -3
�¾����ϴ�. �� ���߾��.
����� ������. 35 - 17 ? [ctrl-z]
����
Assignment #7 (�Ⱓ: 1����)
�� ���α��� ���г������ ������ ���� ���� �����϶�.
- �� ���� ��� ����� ��� 1���ٴ� ũ�� 20 ������ ���̾�� �Ѵ�.
- Ʋ�� �л����Դ� 3���� �� ��ȸ�� �ְ� 3�� ��� Ʋ���� ������ ����ϰ� ���� ������ �Ѿ� ����.
- �°ų� Ʋ���� �� ���� 5���� ���� �ٸ� ���忡�� ���Ƿ� ���� ����Ѵ�.
10�� (Pointer) �о� ����
[ Table Of Contents |
Previous Chapter |
Next Chapter]