CHAPTER 9
PROGRAM STRUCTURE

[IMAGE: An Quarter-Size Version of The Joy of C Front Cover]
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]


  1. LOCAL VARIABLES
  2. GLOBAL VARIABLES
  3. STORAGE CLASSES
  4. TYPE QUALIFIERS
  5. USER-DEFINED TYPES
  6. HEADER FILES
  7. PRIVATE VARIABLES AND FUNCTIONS
  8. CASE STUDY: ABSTRACT DATA TYPES

Objectives





��)

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), ����




Global variable (���� ����): Function �ܺο��� ���ǵǾ� �� �� ��� function���� ��� ����. ���α׷� ���� �� ��� ���� (�޸𸮸� �Ҵ�޾� ���α׷� ���� �ñ��� ��� ����)



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 ����

  1. auto: automatic, default storage class (Ư���� ���ǰ� ������ �ڵ����� auto�� ����)

  2. static: ��� ��Ҹ� ������ �Ҵ�

  3. extern: external, �ٸ� file���� ���ǵ� global variable ����

  4. 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 ;


    Interface Design (Random Number Library)

    Algorithms


    �ǽ�) ������ ���� ��� ������ ���α׷��� �ۼ��϶�.

    ������ �� ���� ���ϱ� �Ǵ� ���⸦ �����Ѵ�. (���ϱ� �Ǵ� ���⸦ ���Ƿ� ����)

    ��� ��)

    ����� ������. 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����)

    �� ���α׷��� ���г������ ������ ���� ���� �����϶�.

    10�� (Pointer) �о� ����


    [ Table Of Contents | Previous Chapter | Next Chapter]