SE 모지리네 촌놈닷컴::가상화, KVM, HYPER-V, Virtualization, 클라우드, CLOUD, LINUX, WINDOW,Security, DDOS, Network > 호스팅 TIP > C http://chonnom.com/bbs/board.php?bo_table=B22 테스트 버전 0.2 (2004-04-26) ko mktime http://chonnom.com/bbs/board.php?bo_table=B22&wr_id=9 mktime
mktime -- 지정된 날짜를 date()함수 등이 사용하는 timestamp로 만든다.
Description
int mktime (int hour, int minute, int second, int month, int day, int year [, int is_dst])
Mktime() is useful for doing date arithmetic and validation, as it will automatically calculate the correct value for out-of-range input.
For example, each of the following lines produces the string "Jan-01-1998".
Example 1. Mktime() example
date ("M-d-Y", mktime (0,0,0,12,32,1997));
date ("M-d-Y", mktime (0,0,0,13,1,1997));
date ("M-d-Y", mktime (0,0,0,1,1,1998));
date ("M-d-Y", mktime (0,0,0,1,1,98));

Year may be a two or four digit value, with values between 0-69 mapping to 2000-2069 and 70-99 to 1970-1999
(on systems where time_t is a 32bit signed integer, as most common today, the valid range for year is somewhere between 1902 and 2037).
The last day of any given month can be expressed as the "0" day of the next month, not the -1 day.
Both of the following examples will produce the string "The last day in Feb 2000 is: 29".
Example 2. Last day of next month
$lastday = mktime (0,0,0,3,0,2000);
strftime ("Last day in Feb 2000 is: %d", $lastday);
$lastday = mktime (0,0,0,4,-31,2000);
strftime ("Last day in Feb 2000 is: %d", $lastday);
( 역자주 : 다음과 같이 date() 함수를 같이 사용하면 과거나 미래의 특정일을 알 수 있다.

$tomorrow = mktime(0,0,0,date("d")+1,date("m"), date("Y"));
$lastmonth = mktime(0,0,0,date("d"),date("m")-1,date("Y"));
$nextyear = mktime(0,0,0,date("d"),date("m"),date("Y")+1); )
]]> 최고관리자 Mon, 23 May 2011 14:07:24 +0900 날짜 / 시간 함수 - strftime() http://chonnom.com/bbs/board.php?bo_table=B22&wr_id=8 strftime
(PHP 3, PHP 4 , PHP 5)
strftime --  지역 설정에 따라 로컬 시간/날짜를 형식화한다.
 
Description
string strftime ( string format [, int timestamp])
date()함수와 동일한 역할을 수행하여 함수 호출 시에 지정해 준 format에 날짜 정보를 출력한다.

setlocale("LC_TIME","ko") 로 설정하면 월명이나 요일명을 한글로 출력할 수도 있다.
다음의 변환 지시자들은 형식화된 문자열로 간주된다.

  %a - 현재 지역 설정에 따라 축약된 요일 이름이 반환된다.
  %A - 현재 지역 설정에 따라 전체 요일 이름이 반환된다.
  %b - 현재 지역 설정에 따라 축약된 월 이름이 반환된다.
  %B - 현재 지역 설정에 따라 전체 월 이름이 반환된다.
  %d - 일자를 두자리로 출력한다.(01~31)
  %e - 일자를 출력하되 10보다 작은 일자는 한자리로 출력.
  %H - 시간을 24시간제로 출력 (00~23)
  %I - 시간을 12시간제로 출력(01~12)
  %j - 일자를 365로 출력
  %m - 월 출력(01~12)
  %M - 분 출력
  %n - 줄바꿈
  %p - 오전 오후 출력
  %r - time in a.m. and p.m. notation  /  AM. PM 표기법
  %R - time in 24 hour notation    / 24시간 표기법
  %S - second as a decimal number
  %t - tab character
  %T - current time, equal to %H:%M:%S

  %u - weekday as a decimal number [1,7], with 1 representing Monday
주의
Sun Solaris seems to start with Sunday as 1 although ISO 9889:1999 (the current C standard) clearly specifies that it should be Monday.
  %U - week number of the current year as a decimal number, starting with the first Sunday as the first day of the first week
  %V - The ISO 8601:1988 week number of the current year as a decimal number, range 01 to 53, where week 1 is the first week that has at least 4 days in the current year, and with Monday as the first day of the week. (Use %G or %g for the year component that corresponds to the week number for the specified timestamp.)
  %W - week number of the current year as a decimal number, starting with the first Monday as the first day of the first week
  %w - day of the week as a decimal, Sunday being 0
  %x - preferred date representation for the current locale without the time
  %X - preferred time representation for the current locale without the date
  %y - year as a decimal number without a century (range 00 to 99)
  %Y - year as a decimal number including the century
  %Z - time zone or name or abbreviation
 
  %% - a literal `%' character
]]> 최고관리자 Mon, 23 May 2011 14:04:40 +0900 gcc Library 경로 지정 http://chonnom.com/bbs/board.php?bo_table=B22&wr_id=7 gcc 컴파일 스크립트를 실행하였는데....

collect2: ld returned 1 exit status
/usr/bin/ld: cannot find -lmysqlclient
collect2: ld returned 1 exit status
/usr/bin/ld: cannot find -lmysqlclient
.......................................................
.......................................................

요런 에러가 나더군요. mysql관련 에러인듯 한데...
스크립트 파일을 열고...확인해보니.. mysqlclient라는 라이브러리 위치가 다르거나 없거나 해서 생기는 오류로 보여집니다...

저에 경우는 해당 라이브러리가 있긴한데.....디폴트경로하고 달라서 생긴오류로... -L 옵션으로 해당 라이브러리 경로를 지정하고 컴파일하니 깔끔하게 됩니다..

-L/usr/local/mysql/lib/mysql   추가...!!

]]> 최고관리자 Fri, 18 Dec 2009 10:39:20 +0900 나만의 ps를 만들어보자 http://chonnom.com/bbs/board.php?bo_table=B22&wr_id=6 나만의 ps를 만들어보자

윤 상배

yundream@joinc.co.kr

교정 과정
교정 0.8 2003년 4월 7일 23시
최초 문서작성
차례
1절. 소개
2절. proc 파일시스템
2.1절. proc 파일시스템에 대하여
2.2절. 프로세스 정보가져오기
3절. 나만의 ps제작
3.1절. 예제코드
3.1.1절. Makefile
3.1.2절. proc.h, proc.cc
3.1.3절. qps.h, qps.cc
3.1.4절. main.cc
3.2절. 테스트
4절. 결론

1절. 소개

대부분의 Unix운영체제는 proc파일시템을 제공한다. proc는 process infomation pseudo의 줄임말이다. 즉 proc파일시스템은 커널에서제공하는 프로세스정보를 저장하고 있는 파일시스템이라고 정리할수 있다.
이 문서는 proc파일시스템을 이용해서 실제 프로세스목록을 출력하는 프로그램제작과 관련된 내용을 담고 있다. 문서는 리눅스운영체제(kernel 2.4.x)를 기준으로 작성되었다.

2절. proc 파일시스템

2.1절. proc 파일시스템에 대하여

리눅스 커널의 주된임무중 하나는 프로세스를 실행시키고 이들을 유지하는 일이며, 이를 위해서 커널데이타구조체를 내부적으로 사용하게 된다. 그런데 이런 프로세스정보는 커널에게만 필요한게 아니고 시스템 관리자혹은 프로그래머들에게도 절대적으로 필요한 정보이다.
그렇다면 필요한 정보를 얻어내기 위해서 어떻게 해야할까? 직접 커널에게 커널데이타구조체를 요청해서 그걸 일일이 분석해야 할까 ? 물론 그렇게도 할수 있겠지만, 이것은 매우 복잡한 작업이며, 또한 (커널모드에서 직접이루어지는 작업임으로)위험한작업이기도 하다. 그래서 리눅스시스템은 사용자레벨에서 프로세스의 상태를 간단하게 확인가능하도록 하기위해서 proc파일시스템을 제공한다.
우리는 복잡하게 커널로부터 여러가지 커널데이타구조체를 요청할필요 없이 proc파일시스템에서 제공하는 정보들을 읽어들이는 정도로 간단하게 프로세스 상태를 얻어올수 있다.
작은 정보: proc파일시스템은 대부분의 유닉스운영체제에서 채택되어지고 있지만, 데이타를 저장하는 범위와 포맷에 있어서 운영체제간 차이점을 보인다. 저장하는 범위의 경우 대부분의 유닉스운영체제는 단지 프로세스 정보만을 제공하는 반면, 리눅스는 프로세스 정보뿐만 아니라 네트웍정보, 파일시스템, 디바이스 정보, 메모리정보, CPU정보등 다양한 정보들을 제공한다.
특히 리눅스의 경우 몇몇정보들에 대해서는 단지 열람만 가능한 수준이 아닌 직접수정을 통해서 커널의 행동을 변경시켜줄수도 있다. 이것은 다른 유닉스에 비해서 매우 확장된 부분이라고 할수 있다.
예를 들어 ICMP요청에 대한 응답을 막고 싶다면 "echo 0 /proc/sys/net/ipv4/icmp_echo_ignore_all"하는 정도로 간단하게 커널의 행동을 변경시켜줄수 있다. 다른운영체제에서의 이러한 작업은 전용관리도구를 사용하든지 리붓팅을 시키든지 해야한다.
저장되는 포맷을 보자면 리눅스는 일반 ASCII문자로 이루어진 반면 다른 유닉스들은 구조체로 정보가 이루어져 있다. 리눅스의 경우 프로세스 정보가 일반문자로 이루어져 있어서 직관적으로 확인하기에 좋기는 하지만 프로그래밍을 할경우 이를 파싱해야되기 때문에 다른 유닉스들에 비해서 좀 불편한점이 되기도 한다.

2.2절. 프로세스 정보가져오기

리눅스의 경우 기능이 확장되긴 했지만 proc파일시스템의 가장큰 사용목적은 뭐니뭐니 해도 프로세스정보를 얻어오는 일이다.
기본적으로 proc파일시스템은 /proc디렉토리안에서 이루어지며, 프로세스정보는 /proc디렉토리밑에 각 프로세스의 PID를 이름으로하는 서브디렉토리 밑에 위치하게 된다. 예를들어 PID가 912인 프로세스라면, 912 프로세스의 정보는 /proc/912(이하 /proc/[PID])밑에 위치하게 된다.
/proc/[PID] 디렉토리밑에는 다시 몇개의 디렉토리와 몇개의 파일들로 이루어져 있다. 
 /proc/[PID]/ -+-- cmdline
               |
               +-- cwd
               |
               +-- environ
               |
               +-- exe 
               |
               +-- fd -------+-- 0
               |             |
               +-- maps      +-- 1
               |
               +-- root 
               |
               +-- stat 
               |
               +-- statm 
               |
               +-- status
리눅스의 경우 위와 같은 파일들로 이루어져 있다. 각 파일이 가지고 있는 자세한 정보들에 대해서는 proc의 man페이지를 참고하기 바란다.
리눅스의 경우 각각의 정보들은 일반 ASCII텍스트문자로 이루어져있고, 대부분의 경우 공백문자(' ')로 필드의 구분이 되어있음으로, 쉽게 원하는 정보들을 얻어올수 있다.

3절. 나만의 ps제작

프로세스정보를 확인하기 위해서 리눅스는 ps라는 도구를 제공한다. ps를 사용함으로써, 우리는 프로세스의 각종중요한 정보들을 얻어오고, 얻어온 정보는 시스템관리와 프로그래밍을 위한 중요한 데이타로 사용한다.
그림 1. ps를 이용한 프로세스상태 확인
우리가 얻고자하는 프로세스데이타는 다음과 같다.
  • 프로세스의 실행유저
  • 프로세스 아이디(PID)
  • 부모프로세스 아이디(PPID)
  • 부모프로세스 상태(Zombie, Run, Sleep 등)
  • 프로세스 이름
  • CPU 사용율(%)
  • VMEM(가상메모리) 사용율
ps에 비해서 몇가지 빠진것들이 있긴하지만 프로세스를 관리하는데 필요한 최소한의 정보는 가져온다.
이 ps도 기본적으로 proc파일시스템에있는 프로세스정보를 이용해서 가져온다. 더 정확히 말하자면 stats에서 필요한 정보를 가져온다. 다음은 실제 stats의 파일내용이다. 원래는 하나의 행으로 되어있으나 출력하기 쉽게 여러개의 행으로 분리했다. 
[root@localhost 2489]# cat stat
2489 (vi) T 2251 2489 2251 772 2581 0 187 0 455 0 12 4 0 0 9 0 0 0 181334 
6950912 0 4294967295 134512640 136413760 3221223720 3221222316 
1074893473 0 0 12288 1333808895 3222310480 0 0 17 0
우리가 만들고자하는 프로그램은 위의 stat 정보를 분석하게 될것이다.

3.1절. 예제코드

프로그램의 이름은 qps로 하도록 하겠다.
이프로그램의 쏘쓰는 몇개의 모듈로 이루어져 있으며, 쏘쓰관리를 위해서 Makefile을 사용할것이다. 다음은 만들고자 하는 qps의 쏘쓰트리 구조이다. 
-+-- Makefile
 |
 +-- main.cc
 |
 +-- proc.cc
 |
 +-- qps.cc
 |
 +-- include ----+-- proc.h 
                 |
                 +-- qps.h
다음은 각 파일들에 대한 설명이다.
표 1. qps 쏘쓰파일 설명
Makefile make에서 사용할 make rule 파일
main.cc main함수를 포함하는 코드, 최소한의 코드만을 가진다
proc.cc 실제 proc파일시스템을 참조해서 각종 프로세스정보를 얻어온다.
qps.cc proc.cc에 정의된 함수를 호출하여 프로세스정보를 얻어오고 이를 화면에 보기좋게 출력한다.
include/proc.h proc.cc에서 사용될 함수선언
include/qps.h qps.cc에서 사용될 함수선언

3.1.1절. Makefile

쏘쓰코드들을 관리하기 위한 Makefile이다. 이해하는데 별다른 어려움은 없을것이다. 
	
#############################################################################
# Makefile for building qps
# Generated by tmake at 23:10, 2003/04/08
#     Project: qps
#    Template: app
#############################################################################

####### Compiler, tools and options

CC  =   gcc
CXX =   g++
CFLAGS  =   -pipe -Wall -W -O2 -DNO_DEBUG
CXXFLAGS=   -pipe -Wall -W -O2 -DNO_DEBUG
INCPATH =   -I./include
LINK    =   g++
LFLAGS  =

TAR =   tar -cf
GZIP    =   gzip -9f

####### Files

HEADERS =   include/proc.h \
        include/qps.h
SOURCES =   main.cc \
        proc.cc \
        qps.cc
OBJECTS =   main.o \
        proc.o \
        qps.o

TARGET  =   qps
INTERFACE_DECL_PATH = .

####### Implicit rules

.SUFFIXES: .cpp .cxx .cc .C .c

.cpp.o:
    $(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

.cxx.o:
    $(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

.cc.o:
    $(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

.C.o:
    $(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

.c.o:
    $(CC) -c $(CFLAGS) $(INCPATH) -o $@ $<

####### Build rules
all: $(TARGET)

$(TARGET): $(UICDECLS) $(OBJECTS) $(OBJMOC)
    $(LINK) $(LFLAGS) -o $(TARGET) $(OBJECTS) $(OBJMOC) $(LIBS)

dist:
    $(TAR) qps.tar qps.pro $(SOURCES) $(HEADERS) $(INTERFACES) $(DIST)
    $(GZIP) qps.tar

clean:
    -rm -f $(OBJECTS) $(OBJMOC) $(SRCMOC) $(UICIMPLS) $(UICDECLS) $(TARGET)
    -rm -f *~ core

####### Compile

main.o: main.cc

proc.o: proc.cc

qps.o: qps.cc

3.1.2절. proc.h, proc.cc

실질적으로 stat를 분석해서 프로세스데이타를 얻어오는 함수들을 포함한다. opendir(2)함수를 이용해서 /proc 디렉토리밑에 있는 파일들의 목록을 얻어오고, 만약 얻어온 파일이 디렉토리이면서 숫자로되어있을경우 프로세스정보 디렉토리라고 판단하고, 서브디렉토리에 있는 stat 파일을 읽어들인다.
읽어들인 stat정보는 " "를 기준으로 파싱해서 배열(vector)에 집어넣는다. 더불어 우리가 만들고자하는 qps프로그램은 해당프로세스의 유저이름도 가져와야 한다. /proc/[PID]/stat 파일은 프로세스소유자의 권한으로 만들어진다. 우리는 stat(2)계열함수를 사용하면 해당 파일의 UID를 얻어올수 있다는걸 알수있다. 또한 getpwuid(3)를 이용하면 해당 UID에 대한 유저이름도 얻어올수 있다.
이렇게 해서 하나의 프로세스에 대한정보가 만들어졌다. 그런데 우리는 프로세스의 목록을 가져와야 함으로 이들 정보는 다시 배열의 원소로 들어가야 할것이다. 이러한 자료구조(배열의 배열)를 위해서 필자는 (속편하게)vector를 사용했다.
다음은 실제 코드들이다. 위의 내용들은 코드를 통해서 이해하기 바란다. 그리어려운 코드들은 아님으로 주석만으로도 충분히 이해가능할것이다.
예제 : include/proc.h 
#ifndef _PROC_H_
#define _PROC_H_

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <vector>
#include <dirent.h>
#include <string>

using namespace std;

// 프로세스 데이타 저장 
typedef struct _process_info
{
    char            username[32];  // 유저이름
    vector<string>  process;       // stat정보들이 들어간다   	
} process_info;

// 프로세스의 리스트를 유지하기 위한 자료구조
// 결국은 배열의 배열이다. 
typedef vector<process_info> Plist;

class Proc
{
    private:
        int         Processnum;     // 현재 프로세스 갯수
        Plist       ProcList;       // 프로세스정보 리스트

    public:
      
        // 생성자및 소멸자 
        Proc();
        ~Proc();

        void            MakeProcInfo();      // 프로세스 정보를 얻어온다.
        vector<string>  ProcParser(char *);  // stat파일을 파싱한다 
        int             ProcNum();           // 현재프로세스 갯수를 넘겨준다.
        int             IsDigit(char *);     // 문자열이 숫자인지 확인한다. 
        Plist           GetProcList();       // 프로세스정보 리스트를 되돌려준다.
};

#endif
 
 
예제 : proc.cc 
#include "proc.h"
#include <iostream>
#include <pwd.h>
#include <sys/types.h>
#include <sys/stat.h>

Proc::Proc()
{
}

Proc::~Proc()
{
}

/*
 * 프로세스 정보를 가져온다. 
 * 그러기 위해서 /proc/[PID]/stat파일을 읽어들이고 이를 
 * 필드별로 파싱한다. 파싱은 " "문자를 기준으로 한다.  
 * 또한 프로세스를 생성한 유저 이름도 얻어온다. 
 */
void Proc::MakeProcInfo()
{
    DIR *directory;
    struct dirent *entry = NULL;
    char proc_file[40];
    vector<string> procinfo; 
    process_info lprocess_info;
    struct stat lstat;

    ProcList.clear();

    // proc 디렉토리를 열어서 파일(디렉토리포함)의 리스트를 
    // 얻어온다.
    if ((directory = opendir("/proc")) == NULL)
    {
        perror("opendir error :");
        exit(0);
    }

    while((entry = readdir(directory)) != NULL)
    {
        if (strcmp(entry->d_name, ".") !=0 &&
            strcmp(entry->d_name, "..") != 0)
        {
            sprintf(proc_file,"/proc/%s/stat", entry->d_name);
            // stat 파일이 존재하는지 확인하고 확인하고
            if (access(proc_file, F_OK) != 0)
            {
                continue;
            }

            // 디렉토리 이름이 숫자인지 확인한다. 
            // 디렉토리 이름이 숫자라면 이를 파싱한다.  
            // 또한 stat파일의 소유 UID를 이용해서 유저이름도 얻어온다. 
            if (IsDigit(entry->d_name))
            {
                struct passwd *upasswd;
                stat(proc_file,&lstat);
                lprocess_info.process  = ProcParser(proc_file);

                upasswd = getpwuid(lstat.st_uid);
                strncpy(lprocess_info.username, upasswd->pw_name, 32);
                if(atoi(lprocess_info.process[0].c_str()) == atoi(entry->d_name))
                {
                    ProcList.push_back(lprocess_info);
                }
            }
            else
            {
            }
        }
    }

}

/*
 * MakeProcInfo를 통해만들어진 프로세스정보 리스트를 되돌려준다.
 */
Plist Proc::GetProcList()
{
    return ProcList;
}

/* 
 * 프로세스의 갯수를 되돌려준다.  
 * 갯수는 프로세스자료구조(vector)의 원소의 크기가 된다. 
 */
int Proc::ProcNum()
{
    return ProcList.size();
}

/*
 * stat 파일을 열어서 " "문자를 기준으로 파싱해서 
 * 배열(vector)에 집어넣는다.   
 */
vector<string> Proc::ProcParser(char *proc_file)
{
    FILE *fp;
    char buf[512] = {0x00,};
    char field[80];
    int index = 0;
    unsigned int i, j = 0;
    vector<string> vproc;

    fp = fopen(proc_file, "r");
    if (fp == NULL)
    {
        perror("error : ");
        exit(0);
    }

    memset(field, 0x00, 80);
    fgets(buf, 511, fp);
    for(i = 0; i < strlen(buf); i++)
    {
        if (buf[i] != ' ' && i != (strlen(buf) -1))
        {
            field[j++] = buf[i];
        }
        else
        {
            if (index == 1)
            {
                field[strlen(field)-1] = 0x00;
                vproc.push_back(field+1);
            }
            else
                vproc.push_back(field);
            memset(field, 0x00, 80);
            j = 0;
            index++;
        }
    }
    fclose(fp);
    return vproc;
}   

/*
 * 파일이름이 숫자인지 확인한다. 
 */ 
int Proc::IsDigit(char *str)
{
    int i;
    for (i = 0; i < strlen(str); i++)
    {
        if (isdigit(str[i])==0)
            return 0;
    }
    return 1;
}

3.1.3절. qps.h, qps.cc

위에서 설명한 proc.cc를 통해서 stat를 분석한 프로세스데이타가 만들어졌음으로 이제 이것을 가지고 와서 화면에 적당히 뿌려줘야 할것이다. 다음은 이와 관련된 함수들이다. 프로세세의 CPU사용율을 가져오기 위한 getcputime()함수외에는 별특별한건 없을것이다.
include/qps.h 
#ifndef _QPS_H_
#define _QPS_H_
#include "proc.h"

// 프로세스 목록을 적당히 가공해서 출력한다.
int viewProc();

// 각프로세스의 CPU 사용율을 얻어온다. 
int getcputime(ulong utime, ulong stime, ulong starttime, int seconds);

// OS의 uptime(부팅후 지금까지의 가동시간)을 얻어온다.  
int uptime();
#endif
qps.cc 
// Local 헤더파일
#include "qps.h"

// 표준 C++ 헤더파일들
#include <iostream>
#include <vector>
#include <string>

// 표준 C 헤더파일
#include <stdio.h>

using namespace std;

/*
 * 프로세스정보 리스트를 얻어와서 보기좋게 출력한다.  
 */
int viewProc()
{
    Proc *mproc;
    unsigned i;
    int pcpu;
    int seconds = 0;

    Plist ProcList;
    mproc = new Proc;
    mproc->MakeProcInfo();

    // 프로세스정보 리스트를 얻어온다. 
    ProcList = mproc->GetProcList(); 

    int total_cpu = 0;  

    // OS의 uptime을 얻어온다. 
    // 얻어온 정보는 프로세스의 CPU 사용율을 구하기 위한 기초정보로 
    // 사용된다.  
    seconds = uptime();
    printf("%-10s %7s %7s %2s %16s %4s %9s\n", "USER", "PID", "PPID",
                                              "ST", "NAME", "CPU", "VMEM"); 
    printf("==============================================================\n");
    for (i = 0; i < mproc->ProcNum(); i++)
    {
        // CPU사용율을 얻어온다. 
        pcpu = getcputime(atol(ProcList[i].process[13].c_str()),
            atol(ProcList[i].process[14].c_str()),
            atol(ProcList[i].process[21].c_str()), seconds);

        // 보기좋게 출력한다. 
        printf("%-10s %7s %7s %2s %16s %2d.%d %9s\n", ProcList[i].username, 
                                    ProcList[i].process[0].c_str(),
                                    ProcList[i].process[3].c_str(),
                                    ProcList[i].process[2].c_str(), 
                                    ProcList[i].process[1].c_str(), pcpu/10, pcpu%10,
                                    ProcList[i].process[22].c_str());
    }   
    return 1;
}

/*
 * 프로세스의 CPU사용율을 얻기 위해서 사용한다. 
 * utime     : 유저모드에서 프로세스가 스케쥴링되면서 사용한 jiffies 수이다. 
 *             프로세스가 스케쥴링될때마다 증가되는 수치이다.  
 * stime     : 커널모드에서 프로세스가 스케쥴링되면서 사용한 jiffies 수이다. 
 * starttime : 운영체제가 시작되고나서 몇 jiffies가 지난후 
 *             프로세스가 시작되었는지 
 */
int getcputime(ulong utime, ulong stime, ulong starttime, int seconds)
{   
    unsigned long long total_time;
    int pcpu=0;

    // 유저 jiffies 와 커널 jiffies를 더한다.
    total_time = utime + stime;

    // 100은 HZ값이다. HZ이 작아질수록 context switching가 빨라진다.  
    // 이값은 /usr/include/asm/param.h에 선언되어 있다. 
    // 100. 대신에 (unsigned long long)HZ 정도로 코드를 
    // 작성하는게 좀더 안전할것이다. 여기에서는 직관적으로 설명하기 
    // 위해서 하드코딩했다.  
    seconds = seconds - (int)(starttime/100.);

    if(seconds)
    {
        pcpu = (int)(total_time * 1000ULL/100.)/seconds;
    }

    return pcpu;
}

/*
 * 운영체제가 부팅하고 나서 얼마의 시간이 지났는지
 */
int uptime()
{
    FILE *fp;
    char buf[36];
    double stime;
    double idletime;

    if ((fp = fopen("/proc/uptime", "r")) == NULL)
    {
        perror("fopen error : ");
        exit(0);
    }
    fgets(buf, 36, fp);
    sscanf(buf, "%lf %lf", &stime, &idletime);
    fclose(fp);

    return (int)stime;
}

3.1.4절. main.cc

main함수다. 더이상 설명할 필요도 없는 간단한 코드이다.
예제 main.cc 
#include <iostream>
#include "qps.h"

int main(int argc, char **argv)
{
        viewProc();
}

3.2절. 테스트

컴파일은 make를 이용하면 된다. 다음은 우리가 만든 프로그램을 실행시킨 화면이다.
그림 2. qps 테스트화면
그럭저럭 잘돌아가는걸 확인할수 있을것이다.

4절. 결론

이상 proc파일시스템을 이용해서 어떻게 프로세스정보를 얻어오는지에 대해서 알아고, 이 얻어온정보를 가공해서 실제 관리자나, 프로그래머에게 유용한 정보로 만드는 방법을 알아보았다.
시간이 남는다면 몇가지 다른 부가적인 시스템정보까지 포함시켜서 Top와 같은 좀더 강력한 프로그램을 만드는것도 재미있을것이다. 혹은 QT, GTK등을 이용해서 GUI환경에서 작동하는 시스템프로세스 모니터링 프로그램을 만들수도 있을것이다. 
]]> 최고관리자 Tue, 01 Dec 2009 10:42:18 +0900 세마포어의 사용 http://chonnom.com/bbs/board.php?bo_table=B22&wr_id=5
http://www.joinc.co.kr/modules/moniwiki/wiki.php/Site/system_programing/IPC/semaphores
 
 
세마포어는 System V IPC 의 설비중 하나로, 하나의 자원에 여러개의 프로세스가 접근하려고 할때, 해당자원에 대한 접근제어를 하기 위해 필요한 설비이다.
이번 강좌를 통해서 세마포어의 사용방법에 대해서 알아보도록 하겠다.


세마포어란 무엇인가
세마포어(Semaphores)를 비록 IPC설비중의 하나로 분류하긴 했지만, 다른 파이프, 메시지큐, FIFO 등과는 좀다르다. 다른 IPC 설비들이 대부분 프로세스간 메시지 전송을 그 목적으로 하는데 반해서 세마포어는 프로세스간 데이타를 동기화 하고 보호하는데 그목적이 있다.

프로세스간 메시지 전송을 하거나, 혹은 공유메모리를 통해서 특정 데이타를 공유하게 될경우 발생하는 문제가, 공유된 자원에 여러개의 프로세스가 동시에 접근을 하면안되며, 단지 한번에 하나의 프로세스만 접근 가능하도록 만들어줘야 할것이다. 이것은 쓰레드에서 메시지간 동기화를 위해서 mutex 를 사용하는것과 같은 이유이다.

하나의 데이타에 여러개의 프로세스가 관여할때 어떤 문제점이 발생할수 있는지 간단한 예를 들어보도록 하겠다. int count=100;
A 프로세스가 count 를 읽어들인다.     100
B 프로세스가 count 를 읽어들인다.     100
B 프로세스가 count 를 1 증가 시킨다.  101
A 프로세스가 count 를 1 증가 시킨다.  101


count 는 공유자원(공유메모리 같은)이며 A와 B 프로그램이 여기에 대한 작업을 한다. A가 1을 증가 시키고 B가 1을 증가시키므로 최종 count 값은 102 가 되어야 할것이다. 그러나 A 가 작업을 마치기 전에 B가 작업을 하게 됨으로 엉뚱한 결과를 보여주게 되었다. 위의 문제를 해결하기 위해서는 count 에 A가 접근할때 B프로세스가 접근하지못하도록 block 시키고, A가 모든 작업을 마쳤을때 B프로세스가 작업을 할수 있도록 block 를 해제 시키면 될것이다.
우리는 세마포어를 이용해서 이러한 작업을 할수 있다. 한마디로 줄여서 세마포어는 "여러개의 프로세스에 의해서 공유된는 자원의 접근제어를 위한 도구" 이다.
세마포어의 작동원리
작동원리는 매우 간단하다. 차단을 원하는 자원에대해서 세마포어를 생성하면 해당자원을 가리키는 세마포어 값이 할당된다. 이 세마포어 값에는 현재 세마포어를 적용하고 있는 자원에 접근할수 있는 프로세스의 숫자를 나타낸다. 이 값이 0이면 이 자원에 접근할수 있는 프로세스의 숫자가 0이라는 뜻이며, 자원), 0보다 큰 정수면 해당 정수의 크기만큼의 프로세스가 자원에 접근할수 있다라는 뜻이 된다. 그러므로 우리는 접근제어를 해야하는 자원에 접근하기 전에 세마포어 값을 검사해서 값이 0이면 자원을 사용할수 있을때까지 기다리고, 0보다 더크면(1이라고 가정하자) 자원에 접근해서 세마포어 값을 1 감소 시켜서, 세마포어 값을 0으로 만들어서, 다른 프로세스가 자원에 접근할수 없도록 하고, 자원의 사용이 끝나면 세마포어 값을 다시 1증가시켜서 다른 프로세스가 자원을 사용할수 있도록 만들어주면 된다.

만약 세마포어 값을 검사했는데 세마포어 값이 0이라면 사용할수 있게 될때까지 (1이 될때까지) 기다리면 (block) 될것이다.
세마포어의 사용
세마포어의 사용은 위의 작동원리를 그대로 적용한다. 즉 1. 세마포어로 제어할 자원을 설정한다.
2. 해당 자원을 사용하기전에 세마포어 값을 확인한다.
3. 세마포어 값이 0보다 크면 자원을 사용하고, 세마포어 값을 1 감소 시킨다.
4. 세마포어 값이 0이면 값이 0보다 커질때까지 block 되며, 0보다 커지게 되면 2번 부터 시작하게 된다.

위의 작업을 위해서 Unix 는 다음과 같은 관련함수들을 제공한다.
view plaincopy to clipboardprint?
  1. #include <sys/types.h>    
  2. #include <sys/ipc.h>    
  3. #include <sys/sem.h>    
  4.   
  5. int semget(key_t key, int nsems, int semflg);    
  6. int semop (int semid, struct sembuf *sops, unsigned nsops);    
  7. int semctl(int semid, int semnum, int cmd, union semun arg);    



세마포어의 관리
세마포어는 그 특성상 원자화된 연산을 필요로 한다. 이러한 원자화된 연산은 유저레벨의 함수에서는 제공하기가 힘들므로, 세마포어 정보는 커널에서 전용 구조체를 이용해서 관리하게 된다. 다음은 커널에서 세모포어 정보를 유지하기 위해서 관리하는 구조체인 semid_ds 구조체의 모습이다. semid_ds 는 /usr/include/bits/sem.h 에 선언되어 있다. (이것은 리눅스에서의 경우로 Unix 버젼에 따라서 위치와 멤버변수에 약간씩 차이가 있을수 있다)
view plaincopy to clipboardprint?
  1. struct semid_ds    
  2. {    
  3.     struct ipc_perm sem_perm;        
  4.     __time_t sem_otime;              
  5.     unsigned long int __unused1;    
  6.     __time_t sem_ctime;              
  7.     unsigned long int __unused2;    
  8.     unsigned long int sem_nsems;      
  9.     unsigned long int __unused3;    
  10.     unsigned long int __unused4;    
  11. };   



sem_perm 은 세마포어에 대한 퍼미션으로 일반 파일퍼미션과 마찬가지의 기능을 제공한다. 즉 현재 세마포어 구조체에 접근할수 있는 사용자권한을 설정한다. sem_nsems 는 생성할수 있는 세마포어의 크기이다. sem_otime 은 마지막으로 세마포어관련 작업을 한 시간(semop 함수를 이용)이며, sem_ctim 은 마지막으로 구조체 정보가 바뀐 시간이다.
semget 을 이용해서 세마포어를 만들자.
세마포어의 생성혹은 기존에 만들어져 있는 세마포어에 접근하기 위해서 유닉스에서 는 semget(2)를 제공한다. 첫번째 아규먼트는 세마포어의 유일한 키값을 위해서 사용하는 int 형의 키값이다. 우리는 이 key 값을 이용해서 유일한 세마포어를 생성하거나 접근할수 있게 된다. 새로 생성되거나 기존의 세마포어에 접근하거나 하는것은 semflg 를 통해서 제어할수 있다. 다음은 semflg 의 아규먼트이다.


IPC_CREAT
만약 커널에 해당 key 값으로 존재하는 세마포어가 없다면, 새로 생성 한다.
IPC_EXCL
IPC_CREAT와 함께 사용하며, 해당 key 값으로 세마포어가 이미 존재한다면 실패값을 리턴한다.
semflg 를 통해서 세마포어에 대한 퍼미션을 지정할수도 있다. 퍼미션 지정은 보통의 파일에 대해서 유저/그룹/other 에 대해서 지정하는것과 같다.

만약 IPC_CREAT 만 사용할경우 해당 key 값으로 존재하는 세마포어가 없다면, 새로 생성하고, 이미 존재한다면 존재하는 세마포어의 id 를 넘겨준다. IPC_EXCL을 사용하면 key 값으로 존재하는 세마포어가 없을경우 새로 생성되고, 이미 존재한다면 존재하는 id 값을 돌려주지 않고 실패값(-1)을 되돌려주고, errno 를 설정한다.

nsems 은 세마포어가 만들어질수 있는 크기이다. 이값은 최초 세마포어를 생성하는 생성자의 경우에 크기가 필요하다(보통 1). 그외에 세마포어에 접근해서 사용하는 소비자의 경우에는 세마포어를 만들지 않고 단지 접근만 할뿐임으로 크기는 0이 된다.

이상의 내용을 정리하면 semget 은 아래와 같이 사용할수 있을것이다. 만약 최초 생성이라면
   sem_num = 1;
그렇지 않고 만들어진 세마포어에 접근하는 것이라면
   sem_num = 0;
sem_id = semget(12345, sem_num, IPC_CREAT|0660)) == -1)
{
   perror("semget error : ");
   return -1;
}


semget 은 성공할경우 int 형의 세마포어 지사자를 되돌려주며, 모든 세마포어에 대한 접근은 이 세마포어 지시자를 사용하게 된다.

위의 코드는 key 12345 를 이용해서 세마포어를 생성하며 퍼미션은 0660으로 설정된다. 세마포어의 크기는 1로 잡혀 있다(대부분의 경우 1). 만약 기존에 key 12345 로 이미 만들어진 세마포어가 있다면 새로 생성하지 않고 기존의 세마포어에 접근할수 있는 세마포어 지시자를 되돌려주게 되고, 커널은 semget 를 통해 넘어온 정보를 이용해서 semid_ds 구조체를 세팅한다.


예제: semget.c
view plaincopy to clipboardprint?
  1. #include <sys/types.h>    
  2. #include <sys/ipc.h>    
  3. #include <sys/sem.h>    
  4.   
  5. int main()    
  6. {    
  7.     int semid;    
  8.     semid = semget((key_t)12345, 1, 0666 | IPC_CREAT);    
  9. }   



이제 위의 코드를 컴파일해서 실행시키고 나서 실제로 세마포어 정보가 어떻게 바뀌였는지 확인해 보도록 하자.

커널에서 관리되는 ipc 정보를 알아보기 위해서는 ipcs(8)라는 도구를 이용하면 된다.
[root@localhost test]# ipcs -s    
------ Semaphore Arrays --------
key        semid      owner      perms      nsems      status      
0x00003039 0          root      666        1        


0x00003039 은 key 12345 의 16진수 표현이다. 퍼미션은 666으로 되어 있고 semget 를 통해서 제대로 설정되어 있음을 알수 있다.
세마포어를 이용해서 접근제어 하기
이제 semget 을 통해서 세마포어를 만들거나 접근했으니, 이제 실제로 세마포어상태를 검사해서 접근제어를 해보도록하자.

이것은 semop를 통해서 이루어진다.

semop 의 첫번째 semid 는 semget 을 통해서 얻은 세마포어 지시자이다. 2번째 아규먼트는 struct sembuf 로써, 어떤 연산을 이루어지게 할런지 결정하기 위해서 사용된다. 구조체의 내은 다음과 같으며, sys/sem.h 에 선언되어 있다.
view plaincopy to clipboardprint?
  1. struct sembuf    
  2. {    
  3.     short sem_num;    // 세마포어의수    
  4.     short sem_op;     // 세마포어 연산지정    
  5.     short sem_flg;    // 연산옵션(flag)    
  6. }   



sem_num 멤버는 세마포어의 수로 여러개의 세마포어를 사용하지 않는다면(즉 배열이 아닐경우) 0을 사용한다. 배열의 인덱스 사이즈라고 생각하면 될것이다. 보통의 경우 하나의 세마포어를 지정해서 사용하므로 0 이 될것이다.
sem_op 를 이용해서 실질적으로 세마포어 연산을 하게 되며, 이것을 이용해서 세마포어 값을 증가시키거나 감소 시킬수 잇다. sem_op 값이 양수일 경우는 자원을 다 썼으니, 세마포어 값을 증가시키겠다는 뜻이며, 음수일 경우에는 세마포어를 사용할것을 요청한다라는 뜻이다. 음수일 경우 세마포어값이 충분하다면 세마포어를 사용할수 있으며, 커널은 세마포어의 값을 음수의 크기의 절대값만큼을 세마포어에서 빼준다. 만약 세마포어의 값이 충분하지 않다면 세번째 아규먼트인 sem_flg 에 따라서 행동이 결정되는데,
sem_flg 가 IPC_NOWAIT로 명시되어 있다면, 해당영역에서 기다리지 않고(none block) 바로 에러코드를 리턴한다. 그렇지 않다면 세마포어를 획득할수 있을때까지 block 되게 된다. sem_flg 는 IPC_NOWAIT 와 SEM_UNDO 2개의 설정할수 있는 값을가지고 있다. IPC_NOWAIT 는 none block 모드 지정을 위해서 사용되며, SEM_UNDO 는 프로세스가 세마포어를 돌려주지 않고 종료해버릴경우 커널에서 알아서 세마포어 값을 조정(증가) 할수 있도록 만들어 준다.

설명이 아마 애매모호한면이 있을것이다. 간단한 상황을 예로 들어서 설명해 보겠다. 현재 세마포어 값이 1 이라고 가정하자.
이때 A 프로세스가 semop 를 통해서 세마포어에 접근을 시도한다.
A는 접근을 위해서 sem_op 에 -1 을 세팅한다. 즉 세마포어 자원을 1 만큼 사용하겠다라는
뜻이다.  
현재 준비된 세마포어 값은 1로 즉시 사용할수 있으므로,
A는 자원을 사용하게 되며, 커널은 세마포어 값을 1 만큼 감소시킨다.

이때 B 라는 프로세스가 세마포어 자원을 1 만큼 사용하겠다라고 요청을 한다.
그러나 지금 세마포어 값은 0 이므로 B는 지금당장 세마포어 를 사용할수 없으며,
기다리거나, 에러값을 리턴 받아야 한다(IPC_NOWAIT).  
B는 자원 사용가능할때까지 기다리기로 결정을 했다.  

잠수후 A는 모든 작업을 다마쳤다.
이제 세마포어를 되돌려줘야 한다. sem_op 에 1 을 세팅하면,
커널은 세마포어 값을 1증가시키게 된다.

드디어 기다리던 B가 세마포어 자원을 사용할수 있는 때가 도래했다.
이제 세마포어 값은 1이 므로 B는 세마포어를 획득하게 된다.  
커널은 세마포어 값을 1 감소 시킨다.
B는 원하는 작업을 한다.
...
...



세마포어 조작
semctl 이란 함수를 이용해서 우리는 세마포어를 조정할수 있다. semctl 은 semid_ds 구조체를 변경함으로써 세마포어의 특성을 조정한다.

첫번째 아규먼트인 semid 는 세마포어 지시자이다. semnum 은 세마포어 배열을 다룰 경우 사용되며, 보통은 0이다. cmd 는 세마포어 조작명령어 셋으로 다음과 같은 조작명령어들을 가지고 있다. 아래는 그중 중요하다고 생각되는 것들만을 설명하였다. 더 자세한 내용은 semctl 에 대한 man 페이지를 참고하기 바란다.
IPC_STAT
세마포어 상태값을 얻어오기 위해 사용되며, 상태값은 arg 에 저장된다.
IPC_RMID
세마포어 를 삭제하기 위해서 사용한다.
IPC_SET
semid_ds 의 ipc_perm 정보를 변경함으로써 세마포어에 대한 권한을 변경한다.
예제를 통한 이해
지금까지 익혔던 내용을 토대로 간단한 예제프로그램을 만들어보겠다. 예제의 상황은 하나의 파일에 2개의 프로세스가 동시에 접근하고자 하는데에서 발생한다. 파일에는 count 숫자가 들어 있으며, 프로세스는 파일을 열어서 count 숫자를 읽어들이고, 여기에 1을 더해서 다시 저장하는 작업을한다. 이것을 세마포어를 통해서 제어하지 않으면 위에서 설명한문제가 발생할것이다.

위의 문제를 해결하기 위해서는 파일을 열기전에 세마포어를 설정해서 한번에 하나의 프로세스만 접근가능하도록 하면 될것이다. 모든 파일작업을 마치게 되면, 세마포어 자원을 돌려줌으로써, 비로서 다른 프로세스가 접근가능하게 만들어야 한다.
예제: sem_test
view plaincopy to clipboardprint?
  1. #include <sys/types.h>    
  2. #include <sys/sem.h>    
  3. #include <sys/ipc.h>    
  4. #include <stdio.h>    
  5. #include <unistd.h>    
  6.   
  7. #define SEMKEY 2345    
  8.   
  9. union semun    
  10. {    
  11.     int val;    
  12.     struct semid_ds *buf;    
  13.     unsigned short int *array;    
  14. };    
  15.   
  16. static int  semid;    
  17. int main(int argc, char **argv)    
  18. {    
  19.     FILE* fp;    
  20.     char buf[11];    
  21.     char count[11];    
  22.   
  23.     union semun sem_union;    
  24.   
  25.     // open 과 close 를 위한 sembuf 구조체를 정의한다.    
  26.     struct sembuf mysem_open  = {0, -1, SEM_UNDO}; // 세마포어 얻기    
  27.     struct sembuf mysem_close = {0, 1, SEM_UNDO};  // 세마포어 돌려주기    
  28.     int sem_num;    
  29.   
  30.     memset(buf, 0x00, 11);    
  31.     memset(count, 0x00, 11);    
  32.   
  33.     // 아규먼트가 있으면 생성자    
  34.     // 그렇지 않으면 소비자이다.    
  35.     if (argc > 1)    
  36.         sem_num = 1;    
  37.     else    
  38.         sem_num = 0;                
  39.   
  40.     // 세마포설정을 한다.    
  41.     semid = semget((key_t)234, sem_num, 0660|IPC_CREAT);    
  42.     if (semid == -1)    
  43.     {    
  44.         perror("semget error ");    
  45.         exit(0);    
  46.     }        
  47.   
  48.     // counter.txt 파일을 열기 위해서 세마포어검사를한다.    
  49.     if(semop(semid, &mysem_open, 1) == -1)    
  50.     {    
  51.         perror("semop error ");    
  52.         exit(0);    
  53.     }    
  54.   
  55.     if ((fp = fopen("counter.txt", "r+")) == NULL)    
  56.     {    
  57.         perror("fopen error ");    
  58.         exit(0);    
  59.     }    
  60.     // 파일의 내용을 읽은후 파일을 처음으로 되돌린다.      
  61.     fgets(buf, 11, fp);    
  62.     rewind(fp);    
  63.   
  64.     // 개행문자를 제거한다.    
  65.     buf[strlen(buf) - 1] = 0x00;    
  66.   
  67.     sprintf(count, "%d\n", atoi(buf) + 1);    
  68.     printf("%s", count);    
  69.     // 10초를 잠들고 난후 count 를 파일에 쓴다.    
  70.     sleep(10);    
  71.     fputs(count,fp);    
  72.   
  73.     fclose(fp);    
  74.     // 모든 작업을 마쳤다면 세마포어 자원을 되될려준다    
  75.     semop(semid, &mysem_close, 1);    
  76.     return 1;    
  77. }    




코드는 매우 간단하지만, 세마포어에 대한 기본적인 이해를 충분히 할수 있을만한 코드이다. 생성자와 소비자의 분리는 프로그램에 넘겨지는 아규먼트를 이용했다. 모든 작업을 마치면 테스트를 위해서 10초를 기다린후에 세마포어를 돌려주도록 코딩되어 있다.

우선 count 를 저장할 파일 counter.txt 를 만들고 여기에는 1을 저장해 놓는다. 그다음 ./sem_test 를 실행시키는데, 최초에는 생성자를 만들어야 하므로 아규먼트를 주어서 실행시키고, 그다음에 실행시킬때는 소비자가 되므로 아규먼트 없이 실행하도록 하자. 다음은 테스트 방법이다.
[root@coco test]# ./sem_test 1&
[1] 3473
36
[root@coco test]# ./sem_test


위 코드를 실행해보면 ./sem_test 1 이 세마포어자원을 돌려주기 전까지 ./sem_test 가 해당영역에서(세마포어 요청하는 부분) 블럭되어 있음을 알수 있고, 충돌없이 count가 잘되는것을 볼수 있을것이다.

세마포어는 커널에서 관리하는데 세마포어를 사용하는 프로세스가 없다고 하더라도 semctl 을 이용해서 제거하지 않는한은 커널에 남아있게 된다. 세마포어 정보를 제거하기 위해서는 semctl 연산을 하든지, 컴퓨터를 리붓 시커거나, ipcrm(8)이란 도구를 사용해서 제거시켜 줘야 한다.
결론
세마포어는 fcntl 과 매우 비슷한 일을 수행하는데, 좀더 세밀한 조정이 가능하다라는 장점을 가지고 있지만 간단한 일을 하기엔 지나치게 복잡한 면이 없잖아 있다. 이럴경우에는 세마포어 대신 fcntl 을 사용하자.
fcntl 은 기회가 되는데로 다루도록 하겠다. ]]> 최고관리자 Tue, 01 Dec 2009 10:41:25 +0900 리눅스 환경에서의 C 프로그래밍 - 4장 변수와 연산자 http://chonnom.com/bbs/board.php?bo_table=B22&wr_id=4

출처 http://teamblog.joinc.co.kr/yundream/189

 

1 변수와 연산자

1.1 C에서 사용되는 문자들

인간이 쓰는 언어의 숫자만 해도 아마 100여개가 넘을거라고 생각된다. C언어는 기계어를 대신해서 사용할 수 있도록 인간의 언어로 쓰여진 프로그래밍 언어인데, 그렇다면 인간의 언어중 어떤 언어를 사용하고 있을까. 답은 영어다. 컴퓨터라는 기계가 영어문명권에서 발명이 되다보니, 컴퓨터에서 프로그램을 만들기 위해 사용한 C언어도 자연스럽게 영어 알파벳을 기본 문자로 사용하도록 만들어 졌다. - 한글로된 컴퓨터 언어를 사용해보자라고 해서 씨앗이라는 한글로 사용가능한 언어가 있었기는 했다. 당시에는 꽤 주목을 받기도 했었는데, 소리소문 없이 잊혀지고 말았다. 그때가 내가 대학 1학년 때인가? 되었던 듯 싶다. -

C에서 사용하는 문자들은 다음과 같다.
a b c d e f g h i j k l m n o p q r s t u v w x y z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
0 1 2 3 4 5 6 7 8 9
! " # % & ' ( ) * + , - . /
: ; < = > ? [ \ ] ^ _ { | } ~
space, tab, newline, form feed
위의 문자셋은 C언어 뿐만 아니라. 다른 거의 대부분의 프로그래밍 언어에서도 기본으로 사용하고 있다.

2바이트 이상의 문자는 주석외에는 사용할 수 없는게 일반적이다.

1.2 변수와 상수

컴퓨터는 연산을 빠르게 하기 위한 기계로, 연속된 수 많은 연산들을 처리해 나간다. 연산에는 연산자와 피연산자가 필요하다는 것은 누구나 알고 있을 것이다.
    +-------------- 피연산자
    |
 +-------+
 |       |
 1   +   2
     |
     +-------------- 연산자
이제 연속된 연산, 예를들어서 1부터 100까지의 숫자를 더하는 연산을 해야한다고 가정해보자. 단순하게 1부터 100까지 더할경우 100번의 덧셈이 필요하게 되는데, 이를 위해서는 각각의 연산결과를 어딘가에 저장을 해야 한다. 이런경우 암산능력이 좋은 사람은 머리에 연산결과를 기억할 것이고, 그렇지 못한 사람은 종이등을 이용하게 될 것이다.

컴퓨터는 메모리공간을 이용한다. 위의 1부터 100까지 더하는 연산을 할경우 매번 메모리의 저장장소에 연산결과를 넣었다 뺐다하는 일을 한다. 이런 컴퓨터의 메모리 공간에는 일련의 숫자로된 주소가 메겨져 있다. 여러분의 컴퓨터의 메모리가 2 Gigabyte라면, 0부터 2147483647까지의 번호가 매겨져 있고, 이중 사용하지 않는 곳의 주소의 번호를 알아내어서 그곳에 연산결과를 저장하는 식이다.

여러분이 연산결과를 저장하기 위해서 2184912 번째 주소를 사용해야 한다라고 가정해보자. 기억해서 사용하기가 그렇게 만만치 않을 것이다. 그래서 사용하기 쉽게, 숫자대신 알파벳문자를 사용해서 해당 주소를 대신 가리키게 된다. 이때 연산의 결과로 저장되는 값을 변수라고 하고, 변수가 저장될 공간을 쉽게 사용하기 위해서 영어로 명명한 것을 변수명 이라고 한다.

변하는 수가 있으면 변치 않는 수가 있을 것이다. 이를 상수라고 하며, 마찬가지로 상수명을 이용해서 상수가 저장될 메모리 공간을 가리키게 된다.

              +----------<--------- sum = 1+2
              |
 +-----------+---+---------+
 | 메모리    |   |         |
 +-----------+---+---------+
위의 그림에서 sum이 변수명이 되고, sum에는 연산의 결과인 3이 저장된다.

간단하게 1+10을 더하는 프로그램을 만들어 보자.
#include <stdio.h>

int main()
{
    int a, b;
    int sum;

    a = 1;
    b = 10
    sum = a+b; 
    printf("%d\n", sum);
}
아직 C문법을 공부하진 못했지만, 대략 이해하는데 어려움이 없을 것이다.
  1. a = 1 : 변수 a가 가리키는 곳에 1을 저장하고
  2. b = 10 : 변수 b가 가리키는 곳에 10을 저장한다.
  3. sum = a+b : 변수 a가 가리키는 곳의 값 1과 변수 b가 가리키는 곳에 저장된 값 10을 가져와서 더하고, 그 결과값인 11을 sum에 저장한다.
  4. 변수 sum이 가리키는 곳에 저장된 값 11을 가져오고 printf라는 함수를 이용해서 화면에 출력한다.

1.2.1 명명 규칙

변수명과 상수명은 알파벳 영문자와 소문자, 숫자,_가 사용될 수 있다. 또한 첫글자는 반드시 '영문소문자','대문자', '_'여야 한다.
변수명 허용여부 설명
sum1 O
Sum_2 O
_sum O
1sum X 첫머리에 숫자가 왔다
sum 1 X 공백이 존재하면 안된다
sum!2 X 특수문자는 사용될 수 없다

1.3 데이터 형과 크기

1.3.1 기본 데이터 형

인간과 달리 사물을 추상화 시켜서 생각할 수 있는 능력이 없는 컴퓨터이다 보니, 데이터가 어떤 종류의 것이며 (데이터형), 어느정도의 크기 (데이터 크기)를 가지고 있는지를 명확히 알려줘야 할 필요가 있다.

인간은 "천원은 큰돈이다"와 "1000+2000=3000" 에서 문자열 "천"과 숫자 "1000"을 구분해 낼 수 있지만 컴퓨터는 도대체 구분해 낼 수가 없기 때문이다.

때문에 모든 언어는 고유의 크기를 가지는 데이터 형(Type)을 제공하고 있다. C언어는 다음과 같은 크기를 가지는 데이터 형이 준비되어 있다.
데이터 형 크기 설명
int 4byte 정수형 숫자
char 1byte 단일 문자
float 4byte 실수
double 8byte 실수

예를 들어 데이터타입이 int인 a라는 변수가 있다고 가정했을 때, 여기에 저장할 수 있는 데이터의 크기는 2^32 이니 0 - 4294967296이 될거라고 생각할 수 있다. 그러나 실제로는 음수를 표현해야 하기 때문에 -2147483648 - 2147483647사이의 값을 저장할 수 있다.

char 형은 하나의 문자를 저장하기 위해서 사용하는데, 2^8에서 음수를 표현해야 하므로 -127 - 128의 값을 사용할 수 있다.

float,과 double 형은 소숫점을 가지는 실수를 표현하기 위해서 사용한다.

1.3.2 signed 와 unsigned형

정수에는 음의 정수와 양의 정수가 있다. 그렇다면 컴퓨터에서 어떻게 음수와 양수가 처리되는지에 대해서 알아보도록 하자. 정수를 저장하기 위한 데이터형은 4byte의 크기를 가지는 int 형이다. 이것을 컴퓨터 메모리 상에서 보자면 다음과 같은 모습을 하고 있을 것이다.
  |<----------- 32 --------->|
   31              ...   43210
  +---------------    -------+
  |                ...       |
  +----------------   -------+
int형 변수 a에 1을 저장했다면, 0번째 비트에 1이, 2를 저장했다면 1번째 비트에 1, 2번째 비트에 0이 저장될 것이다. -1을 저장하고 싶다면 ? 이러한 음의 값의 표시를 위해서 마지막 비트를 따로 남겨 두었다. 즉 31번째 비트에 1이 있으면 음수, 0이 있으면 양수라고 약속을 한 것이다. 다음은 int형 정수가 메모리 상에 어떻게 저장되는지를 나타내고 있다.
  • 2 : 00000000 0000000 00000000 00000010
  • 1 : 00000000 0000000 00000000 00000001
  • 0 : 00000000 0000000 00000000 00000000
여기에서 -가 되면 아래와 같이 표현된다.
  • -1 : 11111111 11111111 11111111 11111111
  • -2 : 11111111 11111111 11111111 11111110
  • -3 : 11111111 11111111 11111111 11111101
이렇게 해보면 양의 정수로 가장큰 수와 음의 정수중 가장 작은 수는 아래와 같음을 계산할 수 있다.
  • 가장 큰 양의 정수 : 011111111 11111111 11111111 11111111 (2147483647)
  • 가장 작은 양의 정수 : 100000000 00000000 00000000 00000000 (-2147483648)

약간 혼란스럽기는 하겠지만, 이해하는데 크게 어려움은 없을 것이다.

이렇게 해서 음의 수를 표현하긴 했는데, 대신에 저장가능한 숫자의 크기가 2^32 에서 2^31으로 2배만큼 줄어듬을 알 수 있다. 그렇다면 음수를 사용할 필요가 없을 경우 굳이 마지막 비트를 음수인지 양수인지를 판단하기 위해서 낭비할 필요가 없을 것이다.

이를 위해서 unsigned가 제공된다. 부호없는 뜻으로 해석하면 되며, 기본 자료형앞에 써주기만 하면 된다. unsigned int는 부호없는 정수를 저장하기 위한 데이터형이다. 동일하게 unsigned char, unsigned double 등의 자료형을 사용할 수 있다. unsigned가 생략될 경우 signed가 적용된다.

100000000 00000000 00000000 00000000가 주어질 경우 signed int 에서는 -2147483648이던 것이 unsigned int 에서는 2147483648이 되는 식이다.

다음은 signed와 unsigned를 이해하기 위한 간단한 C 코드다.
#include <stdio.h>
#include <string.h>

int main()
{
  int a = -2147483648;
  printf("%d\n", a);
  printf("%u\n", a);
  printf("================\n");
  a = a + 1;
  printf("%d\n", a);
  printf("%u\n", a);
}
아래와 같이 컴파일 시키고 결과까지 확인해 보도록 하자.
# gcc -o signed signed.c
# ./signed
-2147483648
2147483648
================
-2147483647
2147483649
printf 함수는 값을 포맷에 맞추어 화면에 출력시키기 위해서 사용하는 함수다. %d는 주어진 인자를 signed int 형으로 출력하라는 포맷옵션이고, %u는 unsigned 형으로 출력하라는 포맷옵션이다.

<scRIPT type=text/javascript> </scRIPT> <scRIPT src="http://pagead2.googlesyndication.com/pagead/show_ads.js" type=text/javascript> </scRIPT> <IFRAME name=google_ads_frame marginWidth=0 marginHeight=0 src="http://pagead2.googlesyndication.com/pagead/ads?client=ca-pub-0339096251232740&dt=1192669792171&lmt=1192669792&prev_fmts=728x90_as&format=468x60_as&output=html&correlator=1192669792109&channel=8014010384&url=http%3A%2F%2Fteamblog.joinc.co.kr%2Fyundream%2F189&ad_type=text_image&ref=http%3A%2F%2Fteamblog.joinc.co.kr%2Fyundream%2F181&cc=100&ga_vid=377354234.1188889436&ga_sid=1192176615&ga_hid=429111676&ga_fc=true&flash=9&u_h=1024&u_w=1280&u_ah=960&u_aw=1280&u_cd=32&u_tz=540&u_his=1&u_java=true" frameBorder=0 width=468 scrolling=no height=60 allowTransparency></IFRAME>

1.4 상수

변수는 말그대로 변하는 수이고, 상수는 말그대로 변하지 않는 수이다.

사용자의 나이를 입력받아서 어떤 일을 하는 프로그램을 만들어야 하는 경우를 생각해보자. 대부분의 사용자가 정상적으로 입력하겠지만, 900, 28129315 와 같은 터무니 없는 수를 입력하는 경우도 발생할 것이다. 이런 문제는 입력가능한 최대값을 정해놓고 비교하는 것으로 해결가능 할것이다.

아래는 컴파일 후 실행가능한 예제 프로그램이다. 이 프로그램은 사용자의 입력을 숫자로 변환한다음 250을 초과하는지를 검사한다.
#include <stdio.h>


int main(int argc, char **argv)
{
    int age;                         // ** 변수 age의 선언
    char buf[12];                    // 사용자의 입력을 저장할 버퍼
    const int maxage=250;            // ** 상수 maxage의 선언

  age = 0;                         // age의 기본값으로 0을 입력한다.
    printf("Your Age is ? ");
    fgets(buf, 11, stdin);           // 표준입력으로 입력을 받아들여서 buf에 저장한다.
    age = atoi(buf);                 // 읽어들인 값을 int 정수형으로 변환한다.

    if (age > maxage)                // age와 maxage를 비교한다. 
    {
        printf("Are you crazy ? \n");
        printf("Max age is %d\n", maxage);
        return 1;
    }
    printf("OK your age is %d\n", age);
    return 0;
}
상수는 const 키워드를 이름 앞에 붙이면된다. 예를 들어 문자열 상수를 선언하기를 원한다면, const char *name = "yundream" 하면 된다. const가 일단 붙으면, 선언할때에만 값을 넣어줄 수 있으며, 중간에 값을 변경할 수 없다. age= atoi(buf) 다음줄에 maxage=180를 넣어보기 바란다. 실행은 커녕 컴파일조차 안될 것이다. 
# gcc -o input input.c
input.c: In function ‘main’:
input.c:13: error: assignment of read-only variable ‘maxage’

상수를 사용하는 이유는 뭘까 ?
상수는 권한을 정함으로써, 프로그래머의 실수를 미연에 방지하고자 할 때 유용하게 사용할 수 있다. 위의 예에서와 같이 maxage는 고정된 값으로 프로그램 여기저기에서 사용될 수 있을 것이다. 만약 이게 변수라면, 프로그래머가 실수로, 한쪽에서는 150, 다른 함수에서는 100 으로 입력하는 등의 문제가 발생할 수 있을 것이고, 이는 프로그램의 심각한 논리적 버그가 될 수 있다. const를 이용해서 변수를 상수로 선언함으로써 이러한 문제를 예방할 수 있다.

1.4.1 변수의 선언과 정의

엄격히 하자면 선언은 이름만 만드는 것이고, 정의는 선언된 이름에 값을 주는 행위다.
  1. int i; // int형 변수 i를 선언하다.
  2. int i=a; // int형 변수 i를 정의하다.
그러나 C에서 변수는 선언과 동시에 정의가 이루어 지므로 차이가 없으므로, 변수 x를 선언했다는 의미는 변수에 대한 선언과 정의까지를 의미한다. C 컴파일러가 int i를 선언함과 동시에 4byte의 메모리 공간을 할당하고, 그 메모리에 있던 값을 사용하게 되기 때문이다. 메모리에 있던 값이 어떤 값인데? 물론 그것은 알 도리가 없다. 프로그램의 실행시 할당된 4byte의 메모리에 어떤값이 있느냐에 따라 달라지기 때문이다. 아래의 프로그램을 연속해서 실행시켜 보기 바란다.
#include <stdio.h>
int main()
{
  int i;
  printf("%d\n", i);
}
실행할 때 마다 값이 달라지는 것을 알 수 있을 것이다. 이렇게 변수를 선언할 경우 어떤 값이 들어 있을지 알 수 없으므로, 선언과 동시에 값을 입력해주는 초기화작업이 필요하다. 초기화 작업을 하지 않을 경우 심각한 문제를 가진 프로그램이 만들어 질 수 있기 때문이다.
<!> 아래의 예제는 좀 더 쉬운 예제로 변경할 필요가 있음..
#include <stdio.h>

int main()
{
  int i = 0;
  int k;
  while(k <= 100)
  {
    i = i+k;
    k++;
  }
  printf("%d\n", i);
}
1부터 100까지의 모든 수를 더하는 프로그램을 만드는게 목적이였지만, i의 값을 초기화 해주지 않은 이유로 전혀 엉뚱한 결과가 출력이 될 것이다. 아래와 같은 방법으로 선언과 동시에 초기화 하거나 혹은 사용하기 전에 초기화 해주는 센스가 필요하다. 
  int k = 0;
  혹은
  int k;
  k = 0;
  while(i< 100)

이미 몇개의 셈플 프로그램의 코드를 (비록 완전히 이해 하지 못했겠지만)보아 왔으므로, 어떻게 변수를 선언해야 하는지에 대한 감은 잡고 있으리라 생각된다. 몇개의 예를 더 드는 것으로 설명을 마치도록 하겠다.
  1. char a : 하나의 문자를 저장하기 위한 문자형 변수 a의 선언
  2. long a : long형 변수 a의 선언
  3. char *a : 메모리의 주소정보를 저장하기 위한 포인터 변수 a의 선언
    • 포인터는 나중에 따로 다룰 것이다.

1.5 연산자

연산자는 단일 문자혹은 단어로 내부함수를 사용할 수 있도록 한다. 우리는 이미 몇개의 예제 프로그램을 통해서 사칙연산을 위한 연산자, 비교연산자를 사용했었다. 이러한 연산자는 결과를 출력하기 위해서 하나이상의 피연산자를 필요로 한다. 사칙연산자라면 2개의 피연산자를 필요로 할 것이다. 예를 들어 덧셈을 위한 연산자인 +를 이용해서 4 + 5를 했다면 2개의 피연산자를 더한 결과로 9를 얻게 될 것이다.

C는 많은 수의 연산자를 제공하는데, 대략 3개의 큰 카테고리로 분류할 수 있다.
  • 대입 연산자 : 변수에 값을 대입하기 위한 연산자
  • 산술 연산자 : +, -, *, / 와 같은 수치계산을 위한 연산자
  • 비교 연산자 : >, =, < 와 같은 비교를 위한 연산자
  • 기타 연산자 : 논리 연산자, 비트 연산자, 캐스트 연산자
이들 연산자는 카테고리 별로 자세히 살펴보도록 하겠다.

1.5.1 대입 연산자

+,- 혹은 함수의 계산에 의해서 만들어진 결과는 변수에 저장이 되어야 한다. 이렇게 어떤 결과값을 다른 변수에 저장하기 위해 사용하는 연산자가 대입 연산자이다. 대입연산자는 =를 사용하며, 하나의 피연산자만을 가진다.

아래에 대입연산자를 사용하는 방법이 나왔다.
int eng, kor, math, total; 

eng = 85;
kor = 76;
math = 80;

total = eng+kor+math;
대입연산자는 =를 기준으로 오른쪽의 값을 왼쪽의 변수에 밀어넣는다. 오른쪽의 값을 변수에 저장한다고 이해하면 된다. 위 코드에서 eng변수에 85가 저장되었음을 알 수 있다.

왼쪽에는 반드시 변수가 와야 한다. 아래는 잘못된 코드다
5 = 2 + 3;

일반적으로 '''='''를 같다라는 의미로 사용하는 경우가 있는데, C에서 '''='''는 비교를 위해서 사용하는 연산자가 아니다. C는 같음을 비교를 위해서 '''=='''를 사용한다. 경험있는 프로그래머도 '''=='''를 쓸곳에 '''='''를 쓰는 잘못은 흔하게 한다.

1.5.2 일반 수치연산자

가장 기본적인 연산을 위해서 사용된다. 사칙연산을 위한 연산자가 대표적이다. 다음은 C언어에서 지원하는 일반 수치연산자들이다. 이들 연산자는 C뿐만 아닌 다른 모든 언어에서 공통적으로 찾아볼 수 있다.
  • + : 덧셈
  • - : 뺄셈
  • / : 나눗셈
  • * : 곱셈
  • % : 나머지값
+와 -는 역수를 만들기 위한 목적으로도 사용된다.
a = 5;
b = -a;
// b에는 -5가 대입된다.

1.5.3 논리 연산자

논리 연산자는 참또는 거짓을 판별하기 위해서 사용된다. C는 다음과 같은 연산자를 지원한다.
  • && : AND (모두 참일 때 참)
  • || : OR (하나라도 참이면 참)
  • ! : NOT (참이면 거짓, 거짓이면 참)

아래의 경우 a가 b보다 크고, b가 c보다 큰 조건이 모두 만족할 때 참이 된다. 
( a > b) && ( b > c)

아래는 약간 더 복잡한 경우다.
(a > b) || !(a > c)
a가 b보다 더크거나 혹은 a 가 c보다 크지 않다면 참이 된다.

1.5.4 증감 연산자

C에서는 ++와 --라는 특수한 형태의 연산자를 제공한다. 이들은 각각 증가연산자와 감소 연산자라고 불리운다.
  • ++ : 변수에 1을 더한다
  • -- : 변수에서 1을 뺀다.

즉 a = a + 1은 a++와 동일한 결과를 보여준다. 또한 ++a와도 동일한다. 코드의 양을 줄여서 가독성을 높이기 위한 목적으로 주로 사용된다- 증감연산자를 사용한다고 해서 반드시 가독성이 좋아지는 건 아니긴 하다 -. 이들 증감연산자는 포인터의 위치를 증가하거나 감소하기 위한 목적으로도 사용할 수 있다. 포인터는 나중에 다루게 될 것이다.


<!> 엄격히 말하자면 a++과 ++a는 사용되는 코드에 따라서 다른 결과를 보여줄 수도 있는데, 이는 나중에 언급하도록 하겠다.

1.5.5 비트 연산자

컴퓨터는 0-9를 사용하는 인간과 달리 0과 1로된 비트를 이용해서 계산을 한다는 것은 다들 알고 있을 것이다. 그러하다 보니 컴퓨터를 이용해서 정보를 제대로 다루기 위해서는 비트를 제대로 이해하고 다루는게 매우 중요하게 된다. 비트 연산자는 비트를 다루기 위한 목적으로 사용한다.

우리가 일반적으로 사용하는 x86컴퓨터의 경우 byte를 기본단위로 사용하게 된다. 때문에 비트연산자를 통해서 비트연산을 할 때에도 byte단위로 연산하게 된다. C는 다음과 같은 비트연산자를 준비하고 있다.
a & b 비트단위 AND AND 연산자
a | b 비트단위 OR OR 연산자
a ~ b 비트단위 exclusive
a << b 왼쪽으로 비트를 이동 쉬프트 연산자
a >> b 오른쪽으로 비트를 이동
~a 1의 보수

& 연산자는 간단하다. 십진수 10와 14가 있을경우 이 두 수를 & 연산하면 다음과 같은 결과를 보여줄 것이다. |연산은 굳이 설명하지 않도록 하겠다.
 10      00000000 00000000 00000000 00001010
 14      00000000 00000000 00000000 00001110
--------------------------------------------
        00000000 00000000 00000000 00001010   10

쉬프트 연산자 중 << 는 비트를 왼쪽으로 이동시킨다. 왼쪽으로 이동시키면 오른쪽이 남게 될건데, 남은 자리는 0으로 채워진다. 6을 << 1하면 12가 될것이다. 
    00000000 00000000 00000000 00000110
    00000000 00000000 00000000 00001100

>>연산자는 오른쪽으로 이동시키는데, 주의할 필요가 있다. 오른쪽으로 이동시키면 왼쪽 비트가 남게 될건데, 이때 남는 비트는 오른쪽에 있던 비트로 채워지게 된다는 점이다. 아래의 예를 보자. 
    10000000 00000000 00000000 00000000 이것을 >> 1하면
    11000000 00000000 00000000 00000000 이렇게 된다.

1.6 연산자의 사용

다음은 지금까지 배운 연산자를 활용한 간단한 프로그램이다.

#include <stdio.h>

int main()
{
    int my_int;
    printf("일반 수치연산 : \n\n");
    my_int = 6;                // 대입
    printf("my_int = %d, -my_int = %d\n", my_int, -my_int);
    
    printf("int 1+2 = %d\n", 1 + 2);
    printf("int 5-1 = %d\n", 5 - 1);
    printf("int 5*1 = %d\n", 5 * 1);
    printf("int 5/2 = %d\n", 5 / 2);
    printf("int 5/2 = %d\n", 5 % 2);

    printf("double 9/4 = %f\n", 9.0 / 4.0); 

}
프로그램의 실행결과가 어떠할런지 예상하는건 어렵지 않을 것이다. 컴파일 후 실행시켜서 예상한 결과가 나왔는지 확인해 보도록 하자.

1.7 연산자 우선순위

연산자 우선순위는 여러개의 연산자로 이루어진 라인 코드가 있을 경우, 어떤 순서로 처리할 것인지를 결정하기 위해서 사용된다. 다음은 2+5*4 의 연산결과를 출력하는 코드다. 
#include <stdio.h>

int main()
{
  printf("%d\n", 2 + 5 * 4);
}
언뜻 새각하기에 28이라는 결과가 나올 거라고 예상할 수 있지만, C는 나름대로의 연산자 우선순위에 따라서 *연산을 +연 산보다 먼저하게 된다. 그래서 22라는 결과가 나오게 된다. 즉 위의 코드의 경우 C는 ((5*4) + 2)로 해석해서 계산을 한다. 눈치챘겠지만 연산순위를 무시하거나 잘못 이해할 경우 전혀 엉뚱한 잘못된 프로그램을 만들어 낼 수 있다.

다음은 C에서 적용되는 연산자 우선순위다. 참고로 결합성은 우선순위가 같은 연산자들이 여럿있을 경우 어느방향으로 처리할 건지를 결정하기 위해 사용된다. 좌->우는 왼쪽에서 먼저, 우->좌는 오른쪽에서 먼저 계산한다는 걸 의미한다.
순위 연산자 결합성
1 (), [], -> 좌-> 우
2 !-, ++, --, +(단항), -(단항), *(포인터), &, sizeof 우->좌
3 *, /, % 좌->우
4 +, - 좌->우
5 <<, >> 좌->우
6 <, <=, >, >= 좌->우
7 ==, != 좌->우
8 &(비트연산자) 좌->우
9 ~ 좌->우
10 ! 좌->우
11 && 좌->우
12 | | 좌->우
13 ?: 좌->우
14 , 우->좌

위의 우선순위를 이해했다면, 아래의 좀 복잡해 보이는 코드가 어떻게 계산될지 예상할 수 있을 것이다.
a=10*3-40/20*12+20%-2
위의 코드는 다음고 가탕이 계산된다.
a=[(10*3)-{(40/20)*15}]+{20%(-2)}

그러나 연산순위를 이해하고 있다고 하더라도 많은 연산이 들어가는 코드를 작성하다 보면 필연적으로 실수를 하게 된다. 게다가 코드의 가독성도 극적으로 떨어진다. a=10*3-40/20*12+20%-2가 무슨일을 하는지 한눈에 이해하기란 쉬운일이 아니다. 그러니 연산순위같은 것에 신경쓰지말고 괄호 ()를 이용해서 직접 우선순위를 정하는 방법을 사용하도록 한다. a=10*3-40/20*12+20%-2를 괄호를 이용하면 다음과 같이 재 작성할 수 있다. 실수도 막아줄 뿐더러, 이해하기도 훨씬 쉽다는걸 느낄 것이다.
a = ( (10*3) - ((40/20)*15) ) + ( 20%(-2) )
]]> 최고관리자 Mon, 30 Nov 2009 19:32:11 +0900 리눅스 환경에서의 C 프로그래밍 - 3장 Start C http://chonnom.com/bbs/board.php?bo_table=B22&wr_id=3 출처 :  http://teamblog.joinc.co.kr/yundream/181
 
 
이 문서는 수정될 수 있습니다. 최신문서는 Joinc Wiki에서 확인하세요.

1 Start C

Linux환경이 대략 구축되었으니, 이제 C언어 개발환경을 구축해 보도록 하자. 대부분의 Linux 배포판이 설치되는 즉시 완전한 개발환경을 구축해줄 테니, 본문의 내용을 읽고 확인하는 정도면 될 것이다. 물론.. 어떤 리눅스 배포판을 사용하고 있던지 간에, 패키지관리 툴정도는 다룰 수 있을 정도는 되어야 할 것이다.

1.1 필요한 요소

개발환경을 위해서는 최소한 아래의 툴들이 필요하다. 아래의 툴들은 완전히 공개되었으며 GPL을 따르는 소프트웨어들이다.

  1. 에디터 : 코드를 짤려면 당연히 에디터가 준비되어 있어야 한다.
  2. 컴파일러 : C언어에 의해서 짜여진 코드는 인간이 쉽게 이해할 수 있는 코드이다. 기계는 이 코드를 이해할 수 없으므로, 기계가 이해할 수 있는 기계어로 변경해줘야 한다. 컴파일러는 인간이 인지할 수 있는 C로 작성된 코드를 컴퓨터가 인지 기계어된 실행파일로 만들어준다. 번역기라고 생각하면 된다.

기본적으로 위의 2개의 툴만 설치되면 C언어를 배우는데, 전혀 문제가 없다. 그러나 C언어를 이용해서 그럴듯한 프로그램을 만들려면 몇가지 툴들이 더 갖추어진 환경을 만들 필요가 있다.

  1. 디버거 : C언어가 아무리 인간이 이해하기 쉽도록 만들어졌다고는 하지만, 여전히 기계(컴퓨터)의 입장에서 생각을 해야 한다. 그러다 보니 많은 실수가 생길 수 밖에 없다. 어떤 실수는 쉽게 찾아낼 수 있지만 어떤 실수는 찾아내기 매우 어렵다. 디버거를 이용하면, 잘못된 부분을 좀더 쉽게 찾아서 수정할 수 있다.
  2. Make툴 : 아주 작은 프로그램이 아닌 이상, 관리나 유지보수의 목적으로 여러개의 코드파일로 구성이 된다. make를 이용하면 이들 코드를 좀더 쉽게 유지할 수 있다. 프로젝트 관리를 위한 툴이라고 보면된다.
  3. 형상관리도구 : cvs, svn등 으로 공동작업을 할때, 코드 파일이 꼬이지 않도록 도와주며, 버젼을 관리할 수 있도록 해준다. 여기에서는 형상관리툴에 대해서는 다루지 않을 것이다. 아마도 꽤 큰 규모의 프로젝트를 하기전엔 필요없긴 하겠지만, 관심이 있다면 링크를 따라가서 읽어보기 바란다.

1.2 개발 환경 만들기

1.2.1 에디터 준비

kdevelop의 개발화면


코드를 만들려면 일단 에디터가 필요하다. Linux에도 다양한 에디터가 준비되어 있는데, 개인적으로 vi나 emacs를 사용할 것을 권장한다. 이들 에디터는 윈도우 사용자라면 익숙하지 않은 터미널 환경을 가지고 있다는 단점이 있다. 이런경우 울트라에디터와 같은 kate와 Visual C++과 같은 통합개발환경인 kdevelop등도 활용할 수 있다.

특히 kdevelop는 높은 수준의 통합개발환경을 제공한다. 그러나 kdevelop를 제대로 사용하기 위해서는, C언어 뿐만 아니라, 디버깅, 프로젝트/형상관리에 대한 내용을 알고 있어야 하기 때문에, 당분간은 이런것도 있구나 하는 수준에서 참고삼아 보기 바란다. 혹시 자바언어를 사용했다면 eclipse에서 사용하능한 CDT라는 C/C++개발 환경도 제공한다.

vi를 추천하는 이유는 에디터로써의 필요한 기능만을 가지고 있기 때문에, 다른 부가적인 것에 신경쓰지 않아도 되기 때문이다. 게다가 원격으로 연결해서 사용하기에도 전혀 문제가 없다 - GUI 방식의 에디터로도 원격작업을 할 수 있긴하지만.. 하지 않느니만 못한 경우가 대부분이다 -. 생소한 입력방식 때문에 처음에 적응하기 약간 까다롭겠지만, 눈 딱감고 한두시간 정도만 연습삼아 사용해 보기 바란다. 얼마안되어 vi마니아가 되어 있는 자신을 발견하게 될것이다.

1.2.2 컴파일러 준비

컴파일러는 인간의 언어에 가까운 C로된 코드를 번역해서 기계어로 만들어주는 일을 한다. 우리가 만든 코드를 실행가능한 프로그램으로 만들려면 반드시 컴파일러를 이용해서 컴파일 과정을 거쳐야 한다. Linux에는 강력한 gcc라는 컴파일러를 제공한다. gcc는 GNU 프로젝트의 결과물로 완전히 공개되어 있으며, 리눅스는 물론이고 거의 대부분의 상용 유닉스와 맥 윈도우즈에서도 사용할 수 있다. 때때로 gcc의 성능에 대해서 의문을 표하기도 하고 실제, 해당 벤더가 제공하는 전용의 컴파일러에 비해서 성능이 떨어지기도 하지만, 대부분의 경우 사용하는데 문제가 없다.

아뭏든 이 문서는 gcc를 기준으로 내용을 채워갈 것이다. 버젼은 3.x 이상으로 하겠다. 최근의 Linux에 설치된 gcc는 최소 3.x에서 4.x 버젼이니 사용하는데 큰 문제가 없을 것이다. 아래와 같은 방법으로 gcc가 설치되어 있는지 확인해 보도록 하자. 만약 gcc가 설치되어 있지 않다면, 배포판에 맞는 패키지 관리자를 통해서 설치해야 한다. 방법은 배포판에 따라서 다르기 때문에 별도로 설명하지 않도록 하겠다. 메뉴얼을 천천히 읽어보기 바란다.

# gcc --version
gcc (GCC) 3.2.2 20030222 (Red Hat Linux 3.2.2-5)
Copyright (C) 2002 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.


 

1.2.3 첫번째 C 프로그램의 작성

C 프로그램이란 C언어를 이용해서 만들어진 프로그램을 뜻한다.

그럼 첫번째 프로그램을 작성해보도록 하자. 유명한 hello world프로그램으로, 실행시키면 화면에 hello world를 출력하는 일을 한다. 에디터로 아래의 코드를 입력해보자. 파일이름은 hello.c로 하자.

#include <stdio.h>

int main(int argc, char **argv)
{
    printf("Hello World\n");
    return 0;
}


간단히 설명을 하도록 하겠다. C언어 학습에 들어가기전에 맛보기 식으로 하는 거니, 이해가 안가더라도 그러려니 하고 넘어가도록 하자. 어차피 나중에 자세히 알아보게 될 것이다.

  1. #include : 외부 함수를 사용하기 위해서 함수가 선언되어 있는 파일을 포함시킬려고 사용한다. stdio.h는 표준입력/표준출력/표준에러와 관련된 함수들이 선언되어 있다.
  2. main 함수 : 프로그램의 본문이다. 프로그램이 실행되기 위해서는 반드시 하나의 main함수가 포함되어 있어야 한다.
  3. printf 함수 : 표준출력을위한 함수로 "Hello World\n"를 모니터 화면에 출력한다.
  4. return : 함수의 결과를 넘겨주기 위해서 사용한다.

이제 gcc 컴파일러를 이용해서 실행가능한 파일로 만들어 보도록 하자.

# gcc -o hello hello.c

hello.c를 컴파일 해서 hello라는 실행파일로 만들어라는 명령이다. 이제 hello를 실행하면 다음과 같이 주어진 일을하는 것을 볼 수 있을 것이다.

# ./hello
Hello World
#

현재 디렉토리에서 명령을 찾도록하기 위해서 ./를 이용했다.

<scRIPT type=text/javascript> </scRIPT> <scRIPT src="http://pagead2.googlesyndication.com/pagead/show_ads.js" type=text/javascript> </scRIPT> <IFRAME name=google_ads_frame marginWidth=0 marginHeight=0 src="http://pagead2.googlesyndication.com/pagead/ads?client=ca-pub-0339096251232740&dt=1192669717640&lmt=1192669717&prev_fmts=728x90_as&format=468x60_as&output=html&correlator=1192669717531&channel=8014010384&url=http%3A%2F%2Fteamblog.joinc.co.kr%2Fyundream%2F181&ad_type=text_image&ref=http%3A%2F%2Fteamblog.joinc.co.kr%2Fyundream%2F181&cc=100&ga_vid=377354234.1188889436&ga_sid=1192176615&ga_hid=1507035797&ga_fc=true&flash=9&u_h=1024&u_w=1280&u_ah=960&u_aw=1280&u_cd=32&u_tz=540&u_his=2&u_java=true" frameBorder=0 width=468 scrolling=no height=60 allowTransparency></IFRAME>

1.2.4 C 프로그램의 구조

모든 프로그램은 특유의 구조를 가지게 된다. 앞 절에서 예로 들었던 hello.c를 이용해서 C 프로그램의 구조에 대해서 알아보도록 하겠다.

  1. 프로그램은 하나 이상의 함수로 이루어진다.
  2. 반드시 하나의 main함수를 포함해야 한다.
  3. 함수는 서로 독립적인 관계에 있다.
1.2.4.1 함수

함수는 주어진 일을 수행하는 코드조각으로 개념적으로 매우 간단하다.

    입력 데이터
    +--\ /--------------+
    |                   |
    |                   |
    +-----------/ \-----+
             출력결과

위의 이미지는 함수의 개념을 전형적으로 설명해주고 있다. 이미 초등학교때 소개된 개념이므로 함수를 이해하는데에는 전혀 문제 없으리라 생각된다.

함수는 어떤 데이터 셋을 집어 넣으면 필요한 연산을 해서 출력 결과를 되돌려준다. 함수는 다음과 같은 구조를 가진다.

return type function_name(argument)
{
   // 코드
}
  1. return type : 출력 데이터의 형(type)를 지정해 준다.
  2. function_name : 함수의 이름으로 각 함수는 이름으로 구분되며, 이름으로 사용할 수 있다.
  3. argument(인자) : 함수에 넘겨지는 값이다.
  4. 함수 코드 : 함수의 본체부분으로 인자를 받아서 연산을 하고 결과값을 되돌려준다.

다음은 두개의 숫자를 입력받아서 더하기연산을 한 후 되돌려주는 가장 간단한 형식의 함수다. 가장 간단한 함수이긴 하지만 모든 함수는 결국 아래의 예와 동일한 구조를 가진다. 

int plus(int a, int b) 
{
    return a+b;
}


하나의 프로그램은 하나 이상의 함수로 구성되어있다. 이 함수들은 입력값과 출력의 형식으로 다른 함수들에게 값을 넘기는 식의 데이터의 흐름으로 주어진 일을 수행한다. 분업화된 컨테이너 벨트를 생각하면 될거 같다.

function.png

1.2.4.2 main 함수

main 함수는 특별한 종류의 함수이며, 프로그램이 시작되는 지점이다. 모든 C 프로그램은 반드시 하나의 main 함수를 포함하고 있어야만 한다. 다른 함수와 마찬가지로 return type, function name, argument의 3요소로 이루어져 있다.

function2.png

다음은 덧셈연산을 하는 sum이라는 함수를 포함한 프로그램이다.

#include <stdio.h>

int sum(int a, int b)
{
    return a+b;
}
int main(int argc, char **argv)
{
    int result;
    result = sum(4, 5);
    return result;
}

완전한 프로그램이 되기 위해서 하나의 main함수를 가지고 있으며, main함수는 내부에서 sum이라는 함수를 호출해서 4와 5를 더하고 결과값을 리턴하고 프로그램을 종료한다. 프로그램이 종료되었으면 어떻게 리턴값을 확인할 수 있을까 ? 다음과 같이 쉘에서 확인 가능하다.

# ./sum
# echo $?
9

echo(1)는 화면에 출력을 하기 위해서 사용하는 쉘내부명령어이다. $?는 가장 최근 실행시킨 프로그램이 리턴한 값이 저장되는 쉘의 특별한 변수다. 어떻게 이런일이 가능한지는 아직은 몰라도 된다. 차차 알아나가게 될 것이다.

1.2.4.3 include


 

1.2.4.4 주석

주석은 부가적인 정보를 알려주기 위해서 사용되는 C언어의 요소다. C언어가 인간의 언어와 상당히 유사하긴 하지만, 여전히 이해하기 힘든면이 있다. 그러다 보니 다른 사람이 코드를 이해하기 힘들며, 심지어 프로그램을 만든 당사자 조차도, 시간이 지나면 왜 이코드를 작성했는지 잊어버리는 경우가 생긴다. 이는 프로그램의 유지보수를 힘들게 만드는 요인이 된다.

주석을 사용하면 이해하기 쉬운 코드를 만들 수 있다. 특히 여러명과 협력해서 작업해야 할경우 주석은 필수적인 요소다. 당연하지만 주석은 기계어로 번역이 되지 않는다. 다음은 주석의 예이다. 

#include <stdio.h>

/*
 * 만든사람 : yundream
 * 하는일 : 두개의 인자를 더한 결과를 리턴한다.
 * 인자 : int a, int b
 */
int sum(int a, int b)
{
    return a+b;
}

// Main 함수 시작 
int main(int argc, char **argv)
{
    int result;
    result = sum(4, 5); // 두개의 인자를 더한다.
    return result;
}

주석은 "/* */"과 "//" 두개를 이용해서 작성할 수 있다. "/* */"는 블럭단위의 주석을 만들기 위해서 사용하며, //는 라인단위의 주석을 만들기 위해서 사용한다. 함수 전체에 대한 상세설명등은 /* */를 코드 중간중간 간단한 설명을 위해서 //를 사용한다.


1.3 C 프로그램이 만들어지는 과정

인간이 이해하기 쉬운 C언어를 이용해서 프로그램을 만들었다면, 이를 컴퓨터가 이해할 수 있는 기계어 파일로 번역해서 컴퓨터가 실행할 수 있는 실행파일의 형태로 만들어야 한다. 이러한 일을 하는 프로그램을 컴파일러라 고 한다. 이미 우리는 hello world 프로그램 예제를 통해서, 컴파일러를 이용해서 실행파일을 만들고 이를 실행시키는 방법에 대해서 알아보았다. 여기에서는 어떠한 과정을 거쳐서 실행파일이 만들어지는지에 대해서 알아보도록 하겠다.

'Pre processor
컴파일러를 실행시키면 가장 먼저 pre compile를 수행한다. 인간은 쉬운프로그램의 작성을 위해서 include나 매크로등을 이용해서 코드의 내용을 축약한다. pre compile는 축약된 내용을 컴파일러가 쉽게 해석할 수 있도록 풀어쓰는 과정이다.

Assembly 코드의 생성
이제 풀어쓴 코드를 가장 원시적인 언어의 형태인 Assembly코드로 만들어준다. 어셈블리코드는 기계어와 1:1로 대응되기 때문에 일단 어셈블리코드로 성공적으로 만들어낸다면 쉽게 기계어형태로 변환할 수 있다.

Object 파일의 생성
Assembly 코드가 만들어졌다면, 이제 이걸 기계어로 변환한다. 이렇게 해서 만들어진 파일을 object파일이라고 한다.

linker
그러나 object파일이 생겼다고 바로 실행될 수 있는게 아니다. 프로그램으로써 실행하기 위해서는 운영체제가 제공하는 다른 여러가지 객체(기능)들과 연결(link)되어야 한다. link과정을 거치면 비로서 실행가능한 완전한 프로그램이 만들어지게 된다.

]]> 최고관리자 Mon, 30 Nov 2009 19:31:05 +0900 리눅스 환경에서의 C 프로그래밍 - 2장 리눅스와 C http://chonnom.com/bbs/board.php?bo_table=B22&wr_id=2

출처 - http://teamblog.joinc.co.kr/yundream/175

1 Linux 와 C

최초에 C는 시스템 프로그래밍을 위한 언어로 개발되었으며, 상업적및 학습적인 용도로 성공한 최초의 운영체제라 할 수 있는 Unix운 영체제를 만드는 데에 사용되었다. 한마디로 Unix와 C는 뗄레야 뗄 수 없는 관계인 것이다. 이견이 있을 수 있지만 운영체제의 선조격인 Unix를 이해하는 것은 컴퓨팅환경을 이해하는 가장 좋은 방법이며, Unix를 이해하는 가장 좋은 방법은 C를 이해하는 것이라 할 수 있다.

Linux 운영체제가 Unix와 전혀 다른 운영체제라고는 하지만 Unix의 모든 철학과 구현을 그대로 포함하고 있으며, 사실상 또다른 Unix운영체제의 한 종류라고 할 수 있다. Unix의 또다른 운영체제라는데 거부감을 가진 리눅서들도 있겠지만 프로그래머의 입장에서 보자면 Linux와 Unix는 동일하다.

굳이 Linux환경에서 C언어를 공부하려는 이유가 여기에 있다. Linux를 이해한다는 것은 Unix를 이해한다는 것이며, 이는 컴퓨팅환경을 이해한다는 의미가 되기 때문이다.

1.1 Linux 에 대해서

1.1.1 Linux의 탄생

Linus Torvalds

필린드 헬싱키 대학원에서 소프트웨어 공학을 전공하던 많은 학생들중 linus Torvalds라는 평범한 대학원생이 있었다. 당시 토발즈는 Andrew Tanenbaum교수에 의해서 개발된 Minix라는 운영체제를 가지고 Unix 시스템에 대한 공부를 하고 있었는데, Minix의 라이센스와 성능등이 자신이 원하는 바에 미치지 못함을 알게 되었다.

그리하여, 나름대로 Unix-like한 운영체제를 만들 계획을 세우고 이를 실행에 옮기게 된다. 이러한 실행의 결과물로 탄생한게 Linux다.

Linux는 애시당초 개인이 취미삼아서 만든 운영체제 이므로, 그 시작은 매우 보잘 것이 없었다. 이러한 Linux운영체제가 개인사용자부터 대기업환경에 까지 널리 사용되게 된것은 인터넷과 GNU의 공로가 절대적이였다.

리누즈는 별 생각 없이 1991년에 자신이 만든 linux(version 0.01)를 뉴스그룹을 통해 공개하게 된다. 공개를 발표하면서 그는 "이는 단지 취미이며 GNU처럼 전문적인 것이 아니다"라고 발표소감을 표현했다. 말그대로 취미삼아 공개했던 linux는 수많은 유능한 프로그래머의 자발적인 참여로 급속한 발전을 이루게 되었으며, 결국 GNU의 여러 프로젝트중 가장 중요한 프로젝트로 이름을 올리는 수준까지 이르게 된다.

이렇게 빠른 성장을 하긴 했지만, 1998년 까지는 학습용 운영체제라는 이미지가 강했다. 그러던 것이 리눅스의 시장에서의 잠재적 성장능력을 눈치챈 레드햇과 같은 몇몇 회사들에 의해서 기업시장의 물꼬가 트이게 된다.

현재는 어떤 소프트웨어 벤더라도 리눅스를 무시할 수 없는 정도가 되었다. IBM, Dell, Oracle, Informix, Intel 등이 전략적으로 Linux를 유/무형으로 지원하고 있다.

1.1.2 Linux의 특징

프로그래머의 관점에서 Linux의 특징을 살펴보도록 하겠다.

  • Linux는 Unix-like 운영체제다.
    많은 Linux와 GNU지지자들이 Linux는 Unix가 아니다라고 하고 있다. 그러나 개발자 입장에서 Linux는 분명 Unix-like한 운영체제다. 실제 Linux 운영체제는 Unix의 여러 철학들을 그대로 적용시키고 있다. 파일, IPC, 각종 시스템/표준지원 함수등 모든 것이 Unix환경과 동일하거나 비슷하다.
  • 학습용으로는 최고다.
    컴퓨팅역사에서 사실상 최초로 등장한 운영체제는 Unix이며, Unix 운영체제의 철학과 설계, 구성은 후에 등장한 모든 운영체제들이 계승하고 있다. 유닉스의 최대? 경쟁상대인 windows도 예외가 아니다. 이는 Unix는 컴퓨팅분야의 학습을 위한 최고의 운영체제임을 의미한다.
    그러나 안타깝게도 이러한 Unix운영체제를 직접 운영하는데에는 "비용"이라는 결정적인 문제가 따르게 된다. Unix운영체제는 매우 비싸며, 상대적으로 고가의 장비에서 돌아가기 때문에, 실무를 뛰는 개발자가 아닌, 학생(혹은 백수)의 신분에서 접하기란 결코 쉽지 않다.
    Linux는 훌륭한 대안이 될 수 있다. Linux는 Unix의 철학을 그대로 계승하고 있으며, 시스템의 모든 것이 Unix와 거의 동일하다. 시스템 명령, 툴들도 동일하게 사용할 수 있으며, Linux에서 만든 프로그램은 거의 수정없이 Unix에서 그대로 사용될 수 있다. 게다가 자유롭게 이용할 수 있으며, 저렴한 PC에서도 훌륭하게 작동된다.

Unix가 학습을 위한 최고의 운영체제라는 의견에 대해서는 이견이 있을 수 있다. 필자의 생각을 정리해 보자면 Unix가 최고의 학습용 운영체제인 이유는 다음과 같다.
  1. Unix는 모든 운영체제의 선조격이다. 대부분의 운영체제가 Unix운영체제 모델을 거의 그대로 따르고 있다.
  2. Network programing, system programing을 위한 라이브러리와 툴, 프로토콜들이 Unix 환경에서 만들어졌다.
  3. RFC, 개발문서의 상당수가 Unix 기준이다(역사가 오래되었기 때문에 당연하다)
  4. 단순한 계층을 가지고 있다. - 윈도우즈 같은 경우는 사용자 편의를 위해서 여러개의 계층을 가지게 된다. 이는 저 깊숙이에 있는 계층을 직접 접근해야 하는 개발자에게는 재앙이 될 수 있다 -
  5. Unix의 철학은 Small is beautifull이다. 이러한 철학은 일반유저에게 불편함으로 다가올 수 있지만 개발자나 프로그래머 학생에게는 장점이 된다. 에디터와 gcc컴파일러 하나가 갖추어지는 것으로 학습/개발환경이 만들어진다.

1.2 C 언어

1.2.1 언어에 대해서

언어는 의사소통을 위한 수단으로 사용된다. 일본인과의 의사소통을 위해서는 일본어를 구사해야 한다. 중국인, 미국인과도 마찬가지가 되겠다. 사람사이의 의사소통을 위해서만 언어가 사용되느냐 하면 그렇지도 않다. 무언가를 제어하고 다루기 위한 모든 부분에 언어는 사용된다. 자연현상을 이해하기 위해서 수학이 사용된다. 기계를 다루기 위해서 제공되는 메뉴얼 역시 언어라고 할 수 있다.

1.3 C 프로그래밍 언어

컴퓨터와 대화하기 위해서는 컴퓨터가 이해할 수 있는 언어인 기계어를 사용해야 한다. 예를 들어서 주어진 숫자들의 목록에서 가장 큰 숫자를 찾도록 할려면 대략 다음과 같은 언어를 컴퓨터에 입력해야 한다. 
0011010011101011100101100100111010000000010101000010110110001010...
한마디로 말해서 인간이 할 짓이 되지 못한다. 도대체 저걸 어떻게 이해하고 명령을 내릴 수 있단 말인가. 그러나 놀랍게도 컴퓨터가 만들어진 초기에는 저러한 기계어를 직접 컴퓨터에 입력하는 방식으로 컴퓨터를 운용했었다.

원래 인간은 게으른 동물이다. 많은 컴퓨터과학자들이 위의 단순무식한 방법이 아닌 좀더 쉬운 방법으로 컴퓨터와 대화하기 위한 방법을 찾기 위해서 노력했었고, 그래서 만들어진게 Assembly 이다. Assembly는 0과 1된 명령을 좀더 인간이 이해하기 쉽게끔 문자화 했다.
.section .data

data_items:                         # 숫자 데이터들
    .long 3,67,34,222,45,75,54,34,44,33,22,11,66,0 
    .section .text
    .globl _start

_start:
    movl $0, %edi                   # move 0 into the index register
    movl data_items(,%edi,4), %eax  # load the first byte of data
    movl %eax, %ebx                 # since this is the first item, %eax is
                                    # the biggest

start_loop:                         # start loop
    cmpl $0, %eax                   # check to see if we ve hit the end
    je loop_exit
    incl %edi                       # load next value
    movl data_items(,%edi,4), %eax
    cmpl %ebx, %eax                 # compare values
    jle start_loop                  # jump to loop beginning if the new
                                    # one isn t bigger
    movl %eax, %ebx                 # move the value as the largest
    jmp start_loop                  # jump to loop beginning
loop_exit:                          # %ebx is the return value,
                                    # and it already has the number

    movl $1, %eax                   #1 is the exit() syscall
    int $0x80
뭐 그래도 여전히 보기 어렵다고 생각할지 모르겠지만 어쨋든 기계어보다는 훨씬 이해하기 쉬울 것이다.

그러나 어셈블리어는 기계어를 1:1로 전환한다. 때문에 기계어 보다는 획기적으로 이해하기 쉽지만, 여전히 인간에게 기계적인 사고방식을 강요하게 만든다.

그래서 좀더 인간적인, 좀더 인간이 사용하기 쉬운 또다른 대안을 찾게 되었고, 그러한 노력의 결과 만들어진게 C언어이다. C 프로그래밍 언어 (이하 C)는 1970년에 Unix운영체제에서 사용하기 위한 목적으로 Dennis Ritchie에 만들어 졌으며, 강력함과 편리함으로 거의 모든 컴퓨터와 운영체제에서 사용하는 가장 성공적인 프로그래밍 언어가 되었다.

이후에 만들어진 C++, Java, Perl, PHP, Python 등의 언어들도 직간접적으로 C의 영향을 받았으며, 최근들어 이들 최신의 언어가 많은 인기를 끌고 있기는 하지만, 여전히 C는 가장 많은 개발자진을 확보 하고 있으며, 많은 수의 프로그램이 여전히 C로 만들어지고 있다.

다음은 C로 만들어진 가장 큰 숫자를 찾는 프로그램이다.
int main()
{
    int i = 0;
    int maxitem = -1;
    int items[] = {3,67,34,222,45,76,54,34,44,33,22,11,66,0};
    while(items[i] != 0)
    {
        if (items[i] > maxitem)    
            maxitem = items[i];
        i++;
    }
    printf("MAX NUM IS : %d\n", maxitem);
}
약간의 센스만 있다면 프로그래머가 아니더라도 이해하기 어렵지 않을 정도다.

엄격히 말하자면 C언어라는 것은 인간이 기계어를 이해하고 사용하기 힘들기 때문에 만들어진 중간단계의 언어라는 것을 알 수 있다. 위의 코드는 인간은 쉽게 이해할 수 있지만 컴퓨터는 이해할 수 없기 때문에, 기계어로 바꾸어주는 컴파일러라는 별도의 프로그램이 필요하게 된다. 이것은 나중에 다루도록 할 것이다.

1.3.1 컴퓨터와 운영체제 그리고 프로그래밍 언어

컴퓨터 몸, 운영체제는 뇌라고 할 수 있다. 그러나 뇌만 가지고서는 할 수 있는 일이 제한적이다. 최소한의 컴퓨터의 유지만 가능할 뿐이고, 어떤 원하는 일을 하기 위해서는 프로그램이 필요하다. 프로그래밍 언어란 이러한 프로그램을 만들기 위한 또다른 프로그램셋 이라고 이해하면 된다.

<scRIPT type=text/javascript> </scRIPT> <scRIPT src="http://pagead2.googlesyndication.com/pagead/show_ads.js" type=text/javascript> </scRIPT>

1.4 왜 Linux와 C 인가

지금에 와서 C는 C++, Java, Perl, Python, Ruby, C# 등의 언어들에 비해서 구닥다리 언어로 취급을 받고 있는게 사실이다. 그러나 여전히 C는 많은 영역에서 쓰여지고 있으며, 만들어지는 전체 프로그램의 (아마도) 적어도 60% 이상이 C로 만들어지고 있다.

C는 여전히 성공적으로 사용되고 있는 언어이다. 그러나 C를 배워야 하는 진정한 이유는 아래와 같이 정리할 수 있다.
  • 가장 오래된 고수준의 언어다.
    C는 실질적으로 성공한 가장 오래된 언어이다. 그만큼 오랜 역사를 가지고 있음을 의미한다. 역사를 알면 시대를 지배할 수 있다.
  • 많은 프로그램들이 C로 작성되었다.
    프로그래밍 기술을 익히는 가장 좋은 방법중 하나는 다른 훌륭한 프로그램을 접하는 것이다. 수십라인의 간단한 프로그램부터 수만/수십만 라인의 거대한 프로그램까지 수많은 C로 된 프로그램들을 인터넷상에서 접할 수 있다.
  • 많은 문서들이 C로 설명되어 졌다.
    알고리즘과 자료구조등을 설명한 대다수의 문서들이 C를 기준으로 테스트되어지고 작성되어서 배포되고 있다. 최근에는 (특히 Python) 다른 언어들로 설명되어진 문서들이 나오고 있지만, 역시 절대다수의 문서들이 C를 기준으로 만들어 지고 있다. 문서의 작성자들이 C언어에 익숙한 경우가 많기 때문이다.
  • 간결하고 단순하다.
    단점이 될 수도 있겠지만, C는 간결하고 단순하다. 이는 다른 부가적인 것에 신경안쓰고, 배우고자 하는 언어의 특징과 활용에 집중할 수 있도록 도와준다.

결론적으로 말하자면 Linux 환경을 이러한 C언어를 배우는데 최적의 환경을 제공한다. 운영체제의 선조격인 Unix의 철학을 그대로 가지고 있으며, 표준을 잘 따르고 있다. 설치 즉시 별도의 비용을 지불할 필요 없이 완전한 개발환경을 구축해준다. 복잡하고 머리아프게 이런저런 라이센스 따지면서 개발환경을 만들 필요가 없으며, 이런 저런 잡다한 것에 신경쓰지 않고, 오로지 개발과 학습에 집중할 수 있도록 도와준다. Linux에서의 C개발환경이 정말 그렇게 환상적인가에 대해서는 이견이 있을 수 있지만, 적어도 학습에 있어서 최상의 환경을 제공해준다는걸 의심할 필요가 없을 것이다.

2 Start Linux

이 문서는 리눅스 활용서가 아니다. 그러므로 프로그래밍을 함에 있어서 반드시 필요하다고 생각되는 리눅스의 특징적인 것들에 대해서 알아보도록 할 것이다.

2.1 Linux Kernel

실질적으로 운영체제라고 하면 Kernel 자체를 가르킨다. kernel이야말로 뇌에 해당되는 핵심적인 부분으로 램, 키보드입력, 모니터 출력, 프로그램 제어와 같은 핵심적인 업무를 수행한다. 나머지는 모두 kernel위에서 돌아가는 (형태가 다른) 프로그램일 뿐이다.

Linux 커널은 리누즈 토발즈가 만들었으며 현재(2006년) 2.6.xx 버전이 배포되고 있다. Linux 커널은 .으로 구분된 3자리의 숫자로 구분을 하는데, 첫번째 자리는 major version, 두번째 자리는 minor version, 마지막 자리는 patch version을 나타낸다.

예를 들어 2.6.12 라고 하면, 커널소스와 기능에 있어서 2번의 큰 변화가 있었으며, 2번의 변화가 이루어진 2.0.0에서 6번의 자잘한 변화가 있었음을 의미한다. 12는 2.6.0에서 12번의 패치수준의 변화를 말해준다.

2.2 배포판

Linux는 모든 소스코드가 완전히 공개되어 있다. 그러다 보니, 다양한 종류의 배포판들이 존재하게 된다. 이러한 배포판들은 주로 어떤 방식으로 패키지(프로그램)들을 관리하는지에 따라서 구분지어 진다.

수백개의 배포판이 있지만 RedHat, Gentoo, Ubuntu, Fedora 등의 배포판이 널리 사용되고 있다. 어떤 배포판을 이용해서 리눅스환경을 구축해도 문제는 없겠지만, 입문용으로는 Fedora나 Ubuntu를 추천한다.

이 문서에서는 배포판을 설치하는 방법에 대해서 다루지는 않을 것이다. 시중에 나와 있는 관련 서적이나 각 배포판 커뮤니티의 설치 문서를 참고하기 바란다.

2.3 리눅스의 특징

개발자인 필자의 입장에서 리눅스는 또 다른 Unix 운영체제다. 여기에 소개된 리눅스의 특징은 거의 대부분이 Unix의 특징 그대로이다. Linux의 특징을 배우면서 덤으로 Unix의 특징까지 배우게 되니 일석이조라 할 수 있겠다.

리눅스의 특징을 자세히 다루는 것은 이 문서의 범위를 완전히 벗어난다. 여기에서는 개발환경을 이해할 수 있는 수준에서의 최소한의 내용만 다룰 것이다.

유닉스가 모든 리눅스의 특징을 가지고 있으므로, 설명에서는 Unix로 통일하도록 하겠다.

2.3.1 다중 사용자

개인이 사용하는 PC의 운영체제로 만들어졌던 DOS, Windows는 달리 Unix는 처음부터 중대형의 컴퓨터를 제어할 목적으로 만들어진 운영체제다. 그런이유로 처음부터 다중사용자 지원을 고려해서 설계가 되었다.

이런 다중 사용자는 대부분의 경우 물리적으로 컴퓨터에서 멀리 떨어져 있으며, NetWork를 이용해서 접속 하게 된다. Unix는 접속이 유효한 접속인지 아닌지(불법적인 사용자나 크래커)를 판단하기 위해서 ID:Password방식의 Login 시스템을 지원한다.

2.3.2 다중 프로세스

프로세스란 운영체제위에서 주어진일을 하는 프로그램의 실행 이미지다. Unix는 다중의 사용자를 지원하고 있으므로, 동시에 여러개의 프로세스를 지원 할 수 있도록 만들어졌다. A사용자가 웹 브라우진을 하는 동안 B사용자는 DataBase작업을 하면서 동시에 mp3를 감상할 수 있다.

2.3.3 높은 이식성

Unix는 운영체제의 80% 이상이 C언어로 만들어졌다. 이는 다른 종류의 컴퓨터에 쉽게 이식할 수 있음을 말한다. Unix는 거의 대부분의 중대형 컴퓨터와 PC/임베디드기기 - Linux -에 설치되어 있다.

2.3.4 단순함

추상적이긴 하지만 유닉스의 단순함은 유닉스의 대표적인 특징이다. 윈도우 사용자가 Unix를 제일 접하면 느끼는게 단순함에서 오는 황당함이다. 도스시절을 보는 것과 같이 컴은 바탕화면에 프롬프트만 깜빡이고 있는걸 보면서 절망을 느낀 사용자도 꽤나 있었을 것이다.

게다가 프로그램역시 너무나 무성의 하기 그지 없다. 아기자기한 아이콘과 다양한 부가기능을 제공하며 마우스 클릭으로 필요한 일을 해결할 수 있는 윈도우와는 달리 Unix의 프로그램은 직접 타이핑을 하고 옵션을 줘서 일을 수행해야 한다. 유닉스 환경에 매우 익숙한 개발자라고 하더라도 파일의 목록을 보여주는 ls의 옵션을 완벽하게 이해하고 사용하는 사람은 아마도 없을 것이다.

그러나 모순되게도 이러한 단순함이 유닉스를 강력하게 만들어준다. 유닉스의 대부분의 기능과 프로그램들은 자기에게 주어진 일만 하며, 복잡한 작업은 철저히 분업화 함으로써 수행을 한다. 텍스트 파일의 내용을 읽어서 Linux가 포함된 라인을 따로 저장하는 일을 하고 싶다고 가정해보자. 간단한 작업같지만 윈도우에서 이러한 일은 원하는 프로그램을 찾아야 하는 지루한 과정을 거쳐야 한다. 유닉스는 아래와 같이 간단하게 해결할 수 있다. 
# cat sample.txt | grep "Linux" > Linux.txt
파일의 내용을 출력하는 cat을 이용해서 내용을 읽어오고, 읽어온 내용을 문자열을 비교할 수 있는 기능을 가진 grep에 보내어서 Linux를 포함한 라인을 Linux.txt에 저장하는 방식이다. 철저히 분업화 되어있음을 알 수 있다.

이러한 단순함은 파이프와 재지향이라는 기술을 통해서 얻어지는 특징이다. 파이프와 재지향에 대해서는 따로 다루게 될 것이다.

2.4 리눅스 환경

리눅스의 환경을 개발에 필요한 최소한의 수준에서 알아보도록 하겠다.

2.4.1 Shell

우리가 컴퓨터를 사용하는데 있어서, 컴퓨터와 운영체제의 복잡한 구성을 이해하고 있을 필요는 없다. 그래야 한다면 컴퓨터는 단지 전문가의 전유물이 되었을 것이다. Shell은 조개껍질이 내부를 감추는 것처럼 컴퓨터와 운영체제를 내부로 숨긴다. Sell을 이용하는 사용자는 운영체제가 어떻게 명령을 수행하는지 등의 복잡한 것에 신경 쓸필요 없이 shell에 간단히 명령을 내림으로써 필요한 작업을 할 수 있도록 만들어준다.

shell.gif

shell은 이를테면 운영체제와 사용자를 연결해주는 일을 하는 프로그램이라고 할 수 있다. 여러종류의 게임이 있듯이 shell도 여러종류의 쉘이 있다. ksh, csh, bash, zshell등이 있으며 리눅스 환경에서는 bash쉘이 가장 널리 사용된다. 쉘 프로그램이라고 부르기도 한다.

쉘은 프롬프트라는 것을 통해서 사용자의 입력을 받아들여서 필요한 일을 수행한다.

Upload new Attachment "prompt.jpg"

윈도우즈에서도 cmd라고 불리우는 쉘을 띄울 수는 있지만, 유닉스의 쉘은 윈도우즈의 쉘과는 다른 차원의 것이다. GUI화면에서 마우스 클릭으로 거의 대부분의 일을 처리하는 윈도우즈와는 달리 유닉스는 거의 모든 작업이 쉘에서 이루어진다. 비록 KDE와 Gnome와 같은 데스크탑 환경이 나오긴 했지만, 여전히 많은 유닉스 유저들이 데스크탑환경을 단지 많은 쉘 창을 띄우기 위한 용도로 사용할 뿐이다.

2.4.2 파일 구조

리눅스의 파일 시스템 구조는 유닉스의 그것과 동일한 계층 구조를 가지고 있으며, 이러한 계층 구조는 디렉토리라는 특수한 형태의 파일을 통해서 만들어진다. 
 /---+--- root
     |
     +--- usr ---+--- local --+--- lib
     |           |            |
     |           |            +--- java
     |           |            |
     |           |            +--- include 
     |           |
     |           +--- bin 
     |           |
     |           +--- src ----+--- apache
     |                        |
     |                        +--- httpd
     |
     +--- home --+-- yundream
                 |
                 +-- younghi
                 |
                 +-- cocoboc

2.4.3 모든 것은 파일이다

유닉스는 모든걸 파일로 취급한다. 위에 잠깐 언급되었던 것처럼 디렉토리도 (특수한 형태)의 파일로 취급할 뿐만 아니라, 하드디스크, 이더넷카드, 프린터, 각종 입출력 포트(USB, PS/2, Serial)등 모든 장치까지 파일로 취급한다. 예를 들자면 하드디스크는 /dev/hda1, /dev/hda2, 플로피디스크 드라이브는 /dev/fd0이름의 파일로 관리한다.

윈도우즈유저라면 이러한 환경이 낯설게 느껴지겠지만, 이는 적어도 개발자의 입장에서 봤을 때는 매우 합리적인 구조다. 모든 걸 파일이라는 동일한 객체로 보게 됨으로써, 동일한 프로그래밍 방식을 적용할 수 있기 때문이다. 각각의 장치를 위한 프로토콜은 제외하더라도, 장치에 읽고/쓰는데 있어서 동일한 프로그래밍 기법을 사용할 수 있으므로 개발 시간을 크게 단축시킬 수 있다.

이러한 장치와 관련된 특수한 파일들은 /dev밑에 위치한다.

2.4.4 파이프와 재지향

Pipe(파이프)는 한쪽객체에서 다른쪽 객체로 어떤 물건을 보내기 위한 통로로 사용된다. 상하수도관이 대표적인 경우가 될것이다. 컨테이너벨트역시 형태는 다르지만 물건을 보내기 위한 통로로 사용된다는 점에서 일종의 파이프라고 할 수 있다.

Unix역시 객체 사이의 물건을 전달하기 위한 목적으로 파이프를 사용한다. 여기에서 객체는 운영체제에서 어떤 작업을 수행하는 최소단위인 프로세스가되며, 물건은 일련의 연속된 bit로 이루어진 데이터가 된다. 
  +------------+        PIPE       +------------+
  | Process A  | --------||------> | Process B  |
  +------------+                   +------------+

파이프는 유닉스 시스템에서 프로세스간 데이터를 전달하기 위해서 가장널리 필수적으로 사용되는 설비다. 다음은 유닉스에서 파이프를 통해서 작업을 하는 일반적인 예다. 파이프없는 유닉스는 앙꼬 없는 찐빵이라 할 수 있다. 쉘에서는 |를 이용해서 파이프를 이용할 수 있다.
// 프로세스 중에서 vi의 정보를 얻어온다. 
# ps -ef | grep vi 

// file.txt를 읽어서 몇라인으로 구성되어 있는지 확인한다. 
# cat file.txt | wc -l 

// 확장자가 .txt인 모든 파일을 읽어서 "joinc"문자열을 가진 파일을 얻어온다.
# cat *.txt | grep "joinc"

// 프로세스 중에서 root유저가 실행한 vi의 정보를 얻어온다.
# ps -ef | grep vi | grep root

재지향은 다른 곳으로 향하게 한다라는 뜻을 가지고 있다. 예를 들자면 화면에 출력되는 데이터를 파일이나 프린터등으로 보내기 위한 용도로 사용할 수 있는데, 이 경우 데이터를 파일로 재지향한다. 데이터를 프린터로 재지향 한다. 라고 말한다. 쉘에서는 >를 이용해서 재지향 할 수 있다. 
// 프로세스 중에서 root유저가 실행한 vi의 정보를 화면이 아닌  
// rootvi.txt 파일로 재지향한다. 
# ps -ef | grep vi | grep root >  rootvi.txt 

// rootvi.txt 파일의 내용을 프린터로 재지향 한다.
// 프린터가 설정되어 있다면 출력이 될 것이다.
# cat rootvi.txt > lp0

>를 이용해서 재지향 할경우 동일한 이름의 파일이 없다면 새로 생성될 것이다. 만약 동일한 이름의 이름의 파일이 있다면, 덮어써버리게 된다. 덮어쓰지 않고 마지막부터 추가되게 할려면 >>를 이용하면 된다. 
// newaddr.txt를 읽어서 addr.txt 파일에 추가한다. 
# cat newaddr.txt >> addr.txt

2.4.5 표준입력,표준출력,표준에러

컴퓨터로 우리가 하는 일은 결국 입력과 출력 두가지 작업으로 요약될 수 있다. 우리가 입력을 통해서 컴퓨터로 명령을 전달하면, 그 결과는 출력의 형태로 우리에게 전달된다. 입력은 키보드로 출력은 모니터를 통해서 이루어진다.

키보드로 통해서 이루어지는 입력을 표준입력이라고 하며, 모니터를 통해서 이루어지는 출력을 표준출력이라고 한다. 그렇다면 표준에러란 무엇인가. 입력은 무조건 하나가 되겠지만, 출력은 한가지 이상이 될 수 있다. 작업을 제대로 마쳤을 경우의 출력결과가 있을 수 있지만 작업을 실패했을 경우의 출력결과가 있을 수도 있기 때문이다. 표준에러는 작업에 실패했다라는 것을 사용자에게 알려주기 위해서 사용한다.

Unix에서는 이러한 입력과 출력까지도 파일로 관리를 한다. 이 파일들은 다음과 같이 입력과 출력에 대응되는 숫자로된 이름을 가지고 있다.
표준입력 0
표준출력 1
표준에러 2

이를 이용해서 재지향을 시킬 때, 표준에러와 표준에러를 따로 저장할 수도 있다.
// 표준출력을 suessvalue.txt로 재지향 한다. 
# ./prog 1> suessvalue.txt

// 표준에러를 error.txt 파일로 저장한다.
# ./prog 2> error.txt
다음과 같은 방법으로 표준에러를 표준출력으로 재지향 시킬 수도 있다.
#./prog 2>&1

2.4.6 계정

리눅스역시 다른 유닉스들과 마찬가지로 다중사용자 운영체제이다. 이렇다 보니 시스템 자원에 대한 접근권한이 매우 중요해 진다. 예를들어 특정 유저의 개인 신상정보를 가진 파일은 결코 다른 유저들이 볼 수 있어서는 안될 것이며 shutdown과 같은 시스템 다운 명령은 특수한 유저(슈퍼유저)만이 제한적으로 실행가능 해야 할것이다. 아뭏든 네트워크장치, 파일, 프로세스, 장치(디스크, CD-ROM, 프린터등)의 모든 시스템 자원에 대해서 사용자 계정수준에서의 접근제어와 관련된 제한이 필요하게 될 것이다. 회사의 직책과 관련된 시스템과 동일하다고 보면 된다. 일반 사원인지, 대리인지, 과장인지, 사장인지에 따라서 접근할수 있는 회사자원의 레벨이 결정되는 것과 마찬가지다. 일반 공지사항이야 전직원이 볼 수 있지만 경영과 관련된 중요 문건은 최고경영진만 볼수 있어야 할것이다.

2.4.6.1 유저
회사로 치면 사원 개개인이다. 리눅스 시스템 관점에서 보자면 시스템에 접근할 수 있는 최소단위 객체가 된다. 유저는 접근을 위해서 자신의 ID와 패스워드를 가지며, 이외에도 시스템에서의 원할한 활동을 위한 "사용자 홈디렉토리", "사용자 쉘", "포함되는 그룹"과 같은 각종 부가적인 정보들을 가지게 된다.

리눅스에서 유저는 크게 2개로 나누게 된다. 절대적인 권한을 가지는 슈퍼유저와 일반유저 유저다.

슈퍼유저는 보통 ID로 root를 가지며 시스템에서 절대적인 영향력을 행사한다. 시스템의 셧다운, 리부팅, 장치의 제어, 유저제어, 파일제어에 있어서 전혀 제한이 없다. 마음만 먹는다면 rm -rf /로 시스템의 모든 파일을 날려버릴 수도 있는 절대 권한자이다. 워낙에 막강한 권한을 가지고 있기 때문에 운영체제 자체를 파괴해 버리는 어처구니 없는 실수를 할 수도 있다. 해서 몇몇 상용운영체제들은 슈퍼유저라도 파워에 제한을 두기도 한다.

일반 유저는 슈퍼유저를 제외한 나머지 유저를 가리킨다. 일반유저는 슈퍼유저가 정하는 바에 따라서 시스템내에서의 권한과 활동영역에 있어서 제한을 받게 된다.

2.4.6.2 그룹
회사에서는 인적자원관리의 효율성을 높이기 위해서 개인별로 직책과 직급을 두고 이를 다시 묶어서 부서(팀)를 만들어서 관리한다. 기술개발팀, 경영지원팀, 회계팀, 인사팀등인데, 한명의 직원은 하나 혹은 그 이상의 팀에 소속될 수 있을 것이고 팀의 특징에 따라서 권한이 재조정 될것이다.

회사와 같이 부서(팀)을 만들어서 조직을 효율적으로 만드는것과 같은 구조는 다른 모든 집단에서 (이름만 약간 바꾸어서) 공통적으로 나타나며 운영체제역시 예외없이 이러한 구조를 따른다.

리눅스에서는 이를 그룹이라고 한다. 리눅스에서의 그룹역시 유저자원을 효율적으로 관리하기 위한 장치다. 하나의 유저는 하나이상의 그룹에 포함될 수 있다.

2.4.6.3 권한
유저와 그룹은 고유의 권한이 있으며, 이러한 권한은 주로 파일에 적용된다. 즉 파일일 읽을수 있는지 (r), 쓸수 있는지 (w), 실행할 수 있는지 (x)에 대해 정의 하는 것으로 이루어진다. 리눅스에서 모든 것은 파일로 다루어지므로 파일에 대해서 권한을 설정한다는 것은 결국 시스템 전체에 대한 권한을 설정하는 것과 동일한 효과를 가진다.

이러한 권한은 유저(User)와 그룹(Group), Other(어디에도 속하지 않은)에 대해서 각각 정의 할 수 있다. 
 유저     그룹     Other
+-+-+-+  +-+-+-+  +-+-+-+
|R|W|X|  |R|W|X|  |R|W|X|
+-+-+-+  +-+-+-+  +-+-+-+
 4 2 1    4 2 1    4 2 1
예를 들어 test.txt파일을 유저 yundream에 대해서 읽기/쓰기/실행 권한을 그룹 
develop와 Other에는 읽기/쓰기 권한이 부여되어 있다면 ls결과는 다음과 같을 것이다. 
$ ls -al
-rw-r--r--   1 yundream develop     5632 2006-04-19 18:09 uname.c
-rwxr-xr-x   1 yundream develop     5632 2006-04-19 18:09 yundream.txt 
이해하는데 별로 어려움없을 것이다. ls는 권한을 7개의 필터로 나타낸다. 
처음 9개 필드가 3개씩 끊어서 유저/그룹/Otehr에 대한 권한을 설정한다. 
마지막 필드는 stiky bit와 같은 특수한 정의를 위해서 사용된다.
[출처] 모지리네 - http://test.mojily.pe.kr/bbs/board.php?bo_table=C_program&wr_id=2
]]> 최고관리자 Mon, 30 Nov 2009 19:28:31 +0900 리눅스 환경에서의 C 프로그래밍 - 1장 소개 http://chonnom.com/bbs/board.php?bo_table=B22&wr_id=1 http://teamblog.joinc.co.kr/yundream/172
소개
컴퓨팅 환경이 지금에 이르게 된 가장 결정적인 원인을 제공한 것은 C라는 언어의 출현이 될것이다. C언어 덕분에 지금의 현대적인 컴퓨팅 환경이 갖추어졌다고 해도 과언이 아닐것이다.


1972년 Unix 운영체제를 위해서 만들어진 C언어는 거의 30년이 지난 지금까지도 가장 인기 있는 프로그래밍 언어중의 하나이다. 객체지향이 일반화 되고 Java, python, C++등의 언어들이 나왔음에도 불구하고, 상업적으로나 학습용으로 확고한 자리를 지키고 있다.


C언어가 이처럼 인기를 끌게되자, 산업현장에서 쉽게 응용할 수 있도록 표준화가 필요해지게 되었으며, 그리하여서 1983년 ANSI(American National Standards Institute)에서 C에 대한 표준을 정의하게 된다. 이후 C를 위한 ANSI표준을 편하게 ANSI C라고 부르게 된다. ANSI C의 최신표준은 C99 이며, 여기에는 C언어를 위한 Scope, Term, Symbol, 환경, 구문요소, 주석, 헤더파일규칙 등 C언어를 사용하는데 있어서 준수해야될 사항들이 정의되어 있다.


ANSI C 표준 권고안
이것은 강제가 아닌 권고이므로 컴파일러를 만드는 단체가 이를 반드시 지킬필요는 없다. 그러나 산업표준이므로 권고를 무시한 컴파일러의 경우 무시당하는 경우가 생길 수 있다. 권고사항을 지키면서 기능확장을 위해서 다른 요소들을 추가시키는 경우는 종종 있다.



이 문서의 내용은 가능한 C의 최신 표준인 C99을 따르게 될것이다. 가능한이라는 단서가 붙은 이유는 필자가 C99의 표준을 완전히 숙지하지 못함으로 표준에서 벗어난 설명이 있을 수 있기 때문이다. 그렇다고 걱정할 필요는 없다. C언어를 이해하고 사용하는데에는 문제가 발생하지 않는 수준은 지킬 것이다.


이 문서는 wiki를 이용해서 만들어질 것이며, 모든 과정이 공개된 상태에서 진행될 것이다. 누구든지 참여가능하다. Version 1이 완료된 시점에서 릴리즈 버젼이 docbook 형식으로 변환할 계획이다.


이 문서는 아래와 같은 사용자를 목표로 내용을 채워나갈 것이다.

C 입문자

Linux 초보 사용자

Linux에서 개발환경을 구축할 수 있을 정도로 간단히 소개

문법은 가능한 간결하게, 필요한 내용만

사실상 if, while 문만 알면 프로그램 만들 수 있다.

가능하면 컴퓨터의 원리 수준에서(지루할 수도 있겠지만)의 이해를 목표로

예를들어 포인터의 경우 구구절절하게 추상적으로 설명하는 것보다, 구체적으로 컴퓨터의 입장에서 포인터가 어떻게 기술되는가 하는 식으로

혹은 signed, unsigned의 설명시 비트의 입장에서 기술하는 식

예제는 남발하지 않는다. 반드시 필요한 곳에서만 사용한다.

문법을 끝낸다음, 리눅스 시스템 프로그래밍으로 한장 정도를 할애해서, 응용에 대한 감을 잡을 수 있는 정도로.

문서의 요소는 3개로 한다.

본문

예제 : 본문의 내용과 관련된 실행가능한 코드의 전부 혹은 일부

중요 : 본문의 흐름을 해치지 않는 수준에서의 팁, 언급, 주석

그림 : 4가지 색이상을 넘지 않도록 한다. 크기는 미정]]> 최고관리자 Mon, 30 Nov 2009 19:27:33 +0900