고급객체지향프로그래밍 객체 지향으로 접근하는 C++ 프로그래밍

고급객체지향프로그래밍고급객체지향프로그래밍객체 지향으로 접근하는 객체 지향으로 접근하는 C++ C++ 프로그래밍프로그래밍

경희대학교경희대학교정연모정연모

1. C++ 1. C++ 언어 개요언어 개요

경희대학교경희대학교이대호이대호

[email protected]@khu.ac.kr 33

C++ C++ 언어의 특징언어의 특징 (1)(1)

1. C 언어 1970 년대 개발 이식성 (portability) 과 유연성 (flexibility) 절차 지향 언어 (procedure oriented language)

2. C++ 언어 객체 지향 언어 (object oriented language) 클래스 (class) 를 통해서 수행 1989 년 이후 ANSI 와 ISO 에 의해 C 와 C++ 표준화


C++ C++ 언어의 특징언어의 특징 (2)(2)

3. 객체 지행 프로그래밍 캡슐화 (encapsulation)

자료와 자료를 처리하는 함수 등을 묶어서 , 사용자가 내부의 구조를 알지 않고도 사용법이나 인터페이스만을 알고 사용할 수 있도록 하는 것

정보 은닉 (information hiding)

상속 (inheritance) 기존에 작성한 클래스를 이용하여 새로운 형식의 클래스를 파생하는 것

다형성 (polymorphism) 같은 이름으로 상황에 따라서 다른 방법으로 동작하는 것 동적 바인딩 (dynamic binding) 으로 실행 시간에 객체의 특성에 따라서 다른

동작을 처리


프로그램 개발 환경프로그램 개발 환경 (1)(1)

1. 명령행 컴파일러 (command line compiler) 사용자의 명령어에 의해 실행 코드로 변환

2. 통합 개발 환경 (IDE, integrated development environment) 편집기 , 컴파일러 , 링커와 디버거 (debugger) 등을 모두 포함한

프로그램 Visual Studio 6.0, Visual Studio 2005 등

3. Visual Studio 최신의 서비스 팩 (service pack) 과 MSDN 라이브러리 (Microsoft

Developer Network Library) 를 설치할 것을 권장





4. Visual Studio 6.0 으로 프로그램 작성 프로젝트 (project) 구성 한 개의 프로그램에서 여러 개의 원시 파일들과 기타 관련 자원들을 관리 프로젝트 생성

[File]-[New]





프로젝트에 원시 파일 추가 [File]-[New]

컴파일과 실행 [Build]-[Build xxx.exe] (xxx 는 프로젝트 이름 )



5. Visual Studio 2005 으로 프로그램 작성 프로젝트는 솔루션 (solution) 으로 관리 프로젝트 생성

[ 파일 ]-[ 새로 만들기 ]-[ 프로젝트 ]



프로젝트에 원시 파일 추가 [ 프로젝트 ]-[ 새 항목 추가 ]

컴파일과 실행 [ 디버그 ]-[ 디버깅하지 않고 시작 ]



6. 빌드 (build) 컴파일 링킹 실행 파일 생성 컴파일 과정에서 오류 (error) 와 경고 (warning) 를 출력 , 만일 오류가

있으면 링킹할 수 없음 링킹 과정에서 오류와 경고를 출력 , 만일 오류가 있으면 실행 파일을

생성할 수 없음 컴파일은 위에서 아래로 진행하므로 항상 상위에서 발생한 오류를 먼저

수정 오류와 경고는 반드시 읽어보고 수정하는 습관이 필요


C++ C++ 프로그램 구조프로그램 구조 (1)(1)

1. C++ 프로그램의 일반적인 형식 주석 (comment)

컴파일 되지 않는 설명

전처리기 (preprocessor) # 으로 시작 컴파일하기 전에 먼저 동작

전역 선언 (global declaration) 프로그램의 모든 영역에서 사용

가능한 것을 선언

main 함수 반드시 한 개 필요한 함수

사용자 정의 함수 (user-defined function) 사용자가 작성한 함수



2. main 함수 프로그램을 실행하면 자동으로 호출 (call, 불려서 실행됨 ) 되는 함수 int main()

반환 (return, 함수가 종료하고 돌려줌 ) 이 정수 (int) 함수 이름이 main ( ) : 매개변수 (parameter) 가 없음

{…} 함수의 몸체 (body), 함수의 동작을 작성

return 0; 함수가 종료되면 0 을 반환



3. 아무런 처리도 하지 않는 프로그램

4. 주석 블록 주석 (block comment)

/* 로 시작해서 */ 로 끝남 줄 주석 (line comment)

// 로 시작해서 작성

// 아무런 처리도 하지 않는 프로그램int main() {

return 0;}



5. #include 전처리기 전처리기 : 컴파일하기 전에 동작 include: 컴파일하기 전에 지정된 파일 ( 헤더 파일 ) 을 원시 코드에 포함



// C 헤더 파일 <stdlib.h> <ctype.h> <math.h> <string.h> <stdio.h> ... // 표준화된 C++ 의 헤더 파일 <cstdlib> <cctype> <cmath> <cstring> <cstdio> ...



6. 식별어 (identifier) 사용자가 필요에 따라서 선언한 것으로 다른 것과 구분할 수 있는 이름 변수 , 상수 , 함수 , 클래스 , 구조체 등의 이름 식별어의 조건

영문자 (A-Z, a-z), 숫자 (0-9), 밑줄 (_) 로 구성 영문자는 대소문자를 구분 식별어의 첫 자는 영문자 또는 밑줄 예약어는 사용할 수 없음

asm auto bool break case catch char class const const_cast continue default delete do double dynamic_cast else enum explicit export extern false float for friend goto if inline int long mutable namespace new operator private protected public register reinterpret_cast return short signed sizeof static static_cast struct switch template throw true try typedef typeid typename union unsigned using virtual void volatile wchar_t while


자료형자료형 (1)(1)

1. 상수 (constant) 수행되기 전에 자료의 값을 미리 정하여 수행 도중에 값이 변하지 않는

숫자나 문자 ( 문자열 ) 리터럴 (literal)

수식에서 표현된 숫자나 문자 그 자체 정의된 상수 (defined constant)

#define 로 지정 메모리 상수 (memory constant)

변수를 상수형으로 지정

#define PI 3.141592 // 정의된 상수 int main() { const double Pi = 3.141592; // 메모리 상수 cout << PI*5*5 << endl; // 5 – 리터럴 cout << Pi*5*5 << endl; return 0; }



2. 정의된 상수 컴파일하기 전에 상수이름을 사용한 곳이 상수값으로 수정

#define PI = 3.141592 int main() { double area; area = PI*5*5; return 0; }

전처리→

int main() { double area; area = = 3.141592*5*5; return 0; }

#define PI 3.141592; int main() { double area; area = PI*5*5; return 0; }

전처리→

int main() { double area; area = 3.141592;*5*5; return 0; }



3. 변수 (variable) 프로그램 수행 도중에 값이 변할 수 있는 자료 변수를 위해 미리 정해 놓은 자료형은 변하지 않음 선언 시에 반드시 그 자료형을 지정

4. C++ 의 자료형



5. 변수의 선언 (declaration)

6. 자료형의 종류와 지정어종류 기본 지정어 선언에 사용되는 지정어빈형 void void불형 bool bool

문자형 char char unsigned char: 부호 없는 char

정수형 int

int: 정수 (16 비트 또는 32 비트 )short (int): 16 비트 정수unsigned (int): 부호 없는 intunsigned short: 부호 없는 16 비트 정수long (int): 32 비트 정수unsigned long: 부호 없는 32 비트 정수

부동 소수점형 float, double

float: 단정도 부동 소수점형 (32 비트 )double: 배정도 부동 소수점형 (64 비트 )long double: 10byte 부동 소수점형



7. 메모리 상수

8. 참조 변수



9. 대입 (assignment) =: 대입 연산자 (assignment operator)

int a, b, c; // 변수 선언 a = 10; // 대입 b = a + 10; // 대입 c = a + b; // 대입 int d = 50; // 선언과 초기화

int a, b; // 변수 선언 a = b = 3; // a = (b = c); 와 동일



10.연산과 자료형 변환 묵시적 형변환 (implicit type conversion)

명시적 형변환 (explicit type conversion) C 형식의 형변환



C++ 의 형변환

이름 설명

static_cast 컴파일 시간에 형변환

reinterpret_cast서로 관련이 없는 형 사이의 변환( 서로 다른 포인터나 , 포인터와 정수 사이 )

dynamic_cast 실행 시간에 형변환

const_cast const 를 없애는 형변환

// 3 에 대한 형변환 (double)3/2 // C 형식의 형변환 static_cast<double>(3)/2 // static cast



11.표준 입 / 출력 스트림

11.표준 출력 스트림 cout 객체와 삽입 연산자 (insertion operator, <<) 에 의해 수행

이름 설명

cout 표준 출력

cerr 표준 오류 출력 ( 버퍼 사용하지 않음 )

clog 표준 오류 출력 ( 버퍼 사용 )

cin 표준 입력

cout << 100; cout << 10+2; cout << (10.5+3.5)/2.5; cout << 100 << 10+2 <<(10.5+3.5)/2.5;



13.표준 입력 스트림 cin 객체와 추출 연산자 (extraction operator, >>) 에 의해 수행

int x, y; cin >> x >> y;


연산자연산자 (1)(1)

1. 연산자의 종류와 기능 연산자 (operator)

피연산자에 대한 덧셈 , 뺄셈 등의 연산을 표시하는 기호

피연산자 (operand) 연산이 수행되는 대상



종류 기능 예

산술 연산자 (arithmetic operator) 산술적인 연산을 수행 +, -, *, /, %

증감 연산자(increment/decrement operator)

1 증가 / 감소 연산을 수행 ++, --

관계 연산자 (relational operator) 대소 관계를 비교 <, >, <=, >=

동등 연산자 (equality operator) 동등 관계를 비교 ==, !=

논리 연산자 (logical operator) 논리적인 연산을 수행 &&, ||, !

대입 연산자(assignment operator)

대입을 수행 =, +=, -=, *=, /=, …

비트 연산자 (bitwise operator) 비트 단위의 연산을 수행 &, |, ~, ^, <<, >>

조건 연산자 (conditional operator) 조건적으로 수행 ?:

기타 연산자 ,( 콤 마 ), sizeof, cast, *, &, …



산술 연산자

종류 형식 의미

+ A+B A 와 B 를 더함

- A-B A 를 B 로 뺌

* A*B A 와 B 를 곱함

/ A/B A 를 B 로 나눔

% A%B A 를 B 로 나눈 나머지


+ +A A 에 양수를 취함

- -A A 에 음수를 취함



증감 연산자

관계 연산자

동등 연산자


++ ++a, a++ a 를 1 증가

-- --a, a-- a 를 1 감소


< A<B A 가 B 보다 작은가 ?

<= A<=B A 가 B 보다 작거나 같은가 ?

> A>B A 가 B 보다 큰가 ?

>= A>=B A 가 B 보다 크거나 같은가 ?


== A==B A 와 B 가 같은가 ?

!= A!=B A 와 B 가 같지 않은가 ( 다른가 )?



논리 연산자


&& A&&B A 와 B 의 논리곱

|| A||B A 와 B 의 논리합

! !A A 의 부정

A B A && B A || B !A

거짓 거짓 거짓 거짓 참

거짓 참 거짓 참 참

참 거짓 거짓 참 거짓

참 참 참 참 거짓



대입 연산자

종류 형식 의미= A=B B 를 A 에 대입+= A+=B A = A + (B)

-= A-=B A = A – (B)

*= A*=B A = A * (B)

/= A/=B A = A / (B)

%= A%=B A = A % (B)

<<= A<<=B A = A << (B)

>>= A>>=B A = A >> (B)

&= A&=B A = A & (B)

^= A^=B A = A ^ (B)

|= A|=B A = A | (B)



비트 연산자


~ ~A비트 단위 보수 (10, 01),비트 단위 부정 (bitwise not)

& A&B A 와 B 의 비트 단위 논리곱 (bitwise and)

| A|B A 와 B 의 비트 단위 논리합 (bitwise or)

^ A^BA 와 B 의 비트 단위 배타적 논리합 (bitwise exclusive or)

<< A<<B A 를 B 비트만큼 좌로 이동 (left shift)

>> A>>B A 를 B 비트만큼 우로 이동 (right shift)



조건 연산자

기타 연산자


? : A?B:C A 가 참이면 B 이고 거짓이면 C

연산자 형식 의미

, A, B 콤마 연산자 , A 를 수행하고 B 를 수행

sizeof sizeof(A) A 가 기억 장치에 저장되는 크기 (byte 단위 )

& &A A 가 기억 장치에 저장된 주소


제어문제어문 (1)(1)

1. 문장과 제어문 문장 (statement)

; 으로 구분된 명령어 코드

제어문 (control statement) 처리를 구분하거나 반복적인 수행 또는 분기 선택문 (selection statement) 반복문 (repetition statement) 분기문 (branch statement) 제어문에서 조건에 의해 수행되는 문장은 기본적으로 하나의 문장

만일 여러 문장을 동시에 수행하는 경우에는 {} 로 묶어 복합 문장 (compound statement) 으로 작성



2. if 문



3. switch 문



switch(n) { case 1: x = 1; // 문장 (1) break; // switch 를 벗어남 case 2: x = 2; // 문장 (2) break; // switch 를 벗어남 default: x = 3; // 문장 (3) }

switch(n) { case 1: case 3: x = 1; // n 이 1 이거나 3 이면 break; // switch 를 벗어남 case 2: case 4: x = 2; // n 이 2 거나 4 이면 break; // switch 를 벗어남 default: x = 3; }



4. 선택문과 반복문



5. while 문

6. for 문

7. do…while 문



8. break 문 반복문이나 switch 문을 강제로 벗어남

9. continue 문 아래의 반복되는 문장을 처리하지 않고 다시 반복을 수행하게 하는

분기문



10.goto 문 사용자가 지정한 레이블의 위치로 분기 레이블은 프로그램의 특정 위치를 지정한 식별어


함수함수 (1)(1)

1. 함수 (function) main 함수 표준 라이브러리 함수 (standard library function) 사용자 정의 함수 (user-defined function)

2. 함수의 형식 인수 (argument): 함수의 매개변수에 전달되는 값 매개변수 (parameter): 인수를 받는 값 반환형 : 함수가 종료될 때 전달되는 값의 자료형


함수함수 (2)(2)

3. 함수의 정의


함수함수 (3)(3)

4. 매개변수와 반환값이 없는 함수 매개변수가 없으므로 인수 없이 호출 반환값이 없으므로 함수 이름 앞에 void 를 지정

void InputMsg() { // 매개변수 없음 , 반환 없음 cout << "Input integer: "; }


함수함수 (4)(4)

5. 매개변수는 있으나 반환값이 없는 함수 매개변수를 가지고 있으므로 인수에 따라서 다른 동작을 처리 반환값으로 결과를 가져오지 못하므로 매개변수에 의한 단순한 처리 (

출력 등 ) 를 수행하는 함수로 주로 사용

void PrintResult(int y) { // int 형 매개변수 , 반환 없음 cout << "y: " << y << endl; }


함수함수 (5)(5)

6. 매개변수는 없으나 반환값이 있는 함수 매개변수가 없으므로 함수에서 수행되는 처리는 동일 반환값으로 결과를 가져옴

int Input() { // 매개변수 없음 , int 반환 int x; cin >> x; return x; }


함수함수 (6)(6)

7. 매개변수와 반환값이 있는 함수 일반적인 형식의 함수

int Fn(int x) { // int 형 매개변수 , int 반환 return 2*x*x + 3*x + 5; }


함수함수 (7)(7)

8. 함수의 호출 호출 (call)

“ 함수명 ()” 로 작성 피호출 함수 (called function, callee function) 가 호출되고 수행이 끝나면 다시 제어가 호출 함수 (calling function, caller function) 로 돌아옴

void Fn1() { // 반환 (return) 값이 없음 … } int Fn2() { // 반환 (return) 값이 있음 … return x; } int Fn3() { Fn1(); // 독립된 수식으로 호출 Fn2(); // 독립된 수식으로 호출 int y = Fn2(); // 수식 안에서 호출 cout << 2*Fn2() + 5 << endl; // 수식 안에서 호출 }


함수함수 (8)(8)

int Fn3() { Fn1(); // 선언 없음 – 오류 Fn2(); // 선언 없음 – 오류 int y = Fn2(); cout << 2*Fn2() + 5 << endl; } void Fn1() { … } int Fn2() { … return x; }


함수함수 (9)(9)


함수함수 (10)(10)

9. 함수의 중복정의 (overloading) 동일한 함수의 이름으로 매개변수를 다르게 정의

void Fn(int x) { … } void Fn(double x) { // Fn 함수의 중복정의 … } void Fn() { // Fn 함수의 중복정의 … }


함수함수 (11)(11)

10.함수의 기본 인수 (default argument) 인수를 지정하지 않고 호출할 때 적용되는 값

void Fn(int x, int y = 10) { // 기본 인수 지정 … }

void Fn(int x, int y = 10) { // 기본 인수 지정 … } void Fn(int x) { // 함수의 중복 정의 … } void Fn2() { Fn(10); // 호출 함수 지정이 모호해짐 - 오류 }


함수함수 (12)(12)

11.값에 의한 호출 (call by value)// 값에 의한 호출#include <iostream> using namespace std; void Swap(int x, int y) {

// x 와 y 를 변경int temp = x;x = y;y = temp;

}int main() {

int x = 10, y = 20;

Swap(x, y); // Swap 호출

cout << x << '\t' << y << endl; // x, y 출력

return 0;}


함수함수 (13)(13)

12.참조에 의한 호출 (call by reference)// 참조에 의한 호출#include <iostream> using namespace std; void Swap(int &x, int &y) {

// x 와 y 를 변경int temp = x;x = y;y = temp;

}int main() {

int x = 10, y = 20;

Swap(x, y); // Swap 호출

cout << x << '\t' << y << endl; // x, y 출력

return 0;}


함수함수 (14)(14)

13.표준 라이브러리 함수 수학 관련 함수

cmath 헤더 파일에 함수의 원형이 선언

int abs(int n); // n( 정수 ) 의 절대값double fabs(double x); // x( 실수 ) 의 절대값double sin(double x); // x 의 sinedouble cos(double x); // x 의 cosinedouble tan(double x); // x 의 tangentdouble exp(double x); // ex, e 의 x 거듭 제곱double log(double x); // log x, 자연 로그 xdouble log10(double x); // log10 x, 상용 로그 x

double pow(double x, double y); // xy, x 의 y 거듭 제곱double sqrt(double x); // x 의 루트


함수함수 (15)(15)

문자 관련 함수 cctype 헤더 파일에 함수의 원형이 선언

int isalpha(int c); // 알파벳인지 판별 , 'A'-'Z',

// 'a'-'z‘

int isdigit(int c); // 숫자인지 판별 , '0'–'9‘

int toupper(int c); // 대문자로 변경int tolower(int c); // 소문자로 변경


함수함수 (16)(16)

기타 자주 사용되는 표준 라이브러리 함수 rand/srand 함수

– 난수 발생 관련 함수– cstdlib 헤더 파일에 함수의 원형이 선언

int rand(); // 0 에서 RAND_MAX 의 임의의 정수를 반환void srand(unsigned int seed); // rand() 의 초기값 설정

exit/abort 함수 프로그램 종료 cstdlib 헤더 파일에 함수의 원형이 선언

void exit(int status);

void abort();


함수함수 (17)(17)

14.재귀 함수 (recursive function) 직접적이나 간접적으로 그 자신을 호출하는 함수

n! 의 예

0! 1

! ( 1)( 2) 2 1n n n n

0! 1

! ( 1)!n n n

int Fact2(int n) { if(n <= 1) return 1; // n 이 0 또는 1 else

return n*Fact2(n-1); // 재귀 호출}


배열배열 (1)(1)

1. 배열의 선언 선언에서 크기는 상수형 양의 정수

2. 배열의 요소 (element) 배열의 선언에서 만들어진

낱개의 변수 첨자 연산자 (subscript operator, [])

로 접근

int ary[10] ; // 배열 선언 int i; for(i = 0 ; i < 10 ; i++) cin >> ary[i]; // i번 배열 요소를 키보드로 입력 (0-9)


배열배열 (2)(2)

3. 배열 초기화

int ary1[5] = {10, 20, 30, 40, 50}; // 초기화 int ary2[] = {15, 25, 35}; // 초기화 int ary2[3]; 으로 지정 int ary3[5] = {0}; // 초기화 {0, 0, 0, 0, 0}


배열배열 (3)(3)

4. 배열과 함수 배열의 요소를 함수의 인수로 전달

일반 변수와 동일 배열 전체를 전달

배열의 이름을 인수로 전달 주소에 의한 호출 함수의 매개변수가 가리키는 배열의 요소는 인수로 사용된 배열의 요소와

동일


배열배열 (4)(4)

5. 문자열 (string) 문자형 배열 가변 길이 문자열 : 문자열의 마지막에 구분 문자 사용

char str[15] = "Programming"; str[0] = 'p'; // "programming" 으로 수정 str[7] = '\0'; // ('\0' = NULL, = 0), "program" 으로 수정 str = "C++"; // 사용 불가


배열배열 (6)(6)

문자열 처리 함수

함수 기능size_t strlen(const char *str) str 문자열의 길이를 반환

char *strcpy(char *toStr, const char *fromStr)

fromStr 문자열을 toStr 에 복사

char *strncpy(cahr *toStr, const char *fromStr, size_t size)

fromStr 문자열을 size 길이만큼 toStr 에 복사

int strcmp(const char *str1, const char *str2)

str1 문자열과 str2 문자열을 비교

int strcnmp(const char *str1, const char *str2, size_t size)

str1 문자열과 str2 문자열을 size 길이만큼 비교

char *strcat(char *str1, const char *str2)

str2 문자열을 str1 문자열 뒤에 추가

char *strncat(char *str1, const *char str2, size_t size)

str2 문자열의 size 개의 문자를 str1 문자열 뒤에 추가

char *strchr(const char *str, int ch) str 문자열에 ch 문자가 있는 처음 위치의 주소


배열배열 (7)(7)

6. 광폭 문자 (wide character) 2 바이트 (unsigned char) 형 자료로 한 개의 문자를 표현 wchar_t 형

7. 2 차원 배열 1 차원 배열의 배열 선언에서 크기 1 인 1 차원 배열이 크기 2 개 만큼 생성

8. 3 차원 배열 1 차원 배열의 배열인 2 차원 배열을 배열로 가지는 배열


배열배열 (8)(8)

// 3 크기를 가지는 1 차원 배열이 2 개 int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}}; int matrix[2][3] = {1, 2, 3, 4, 5, 6}; // {{1, 2, 3}, {4, 5, 6}}


포인터포인터 (1)(1)

1. 포인터 (pointer) 변수의 주소를 저장하는 자료



2. 간접 연산자 (indirect operator) 역참조 연산자 (dereference operator), * 포인터 변수에 저장된 주소의 자료



3. 주소에 의한 호출 (call by address) 함수의 매개변수가 주소를 저장할 수 있는 포인터 변수

void Fn(int *p); // 호출되는 함수 – 포인터를 매개변수로 사용 … void Fn2(…) { int x; … Fn(&x); // 주소에 의한 호출 … }



4. 배열과 포인터

double ary[10]; double *p1 = ary; // 배열의 시작 주소를 포인터에 저장 double *p2 = &ary[0]; // 배열의 시작 주소를 포인터에 저장

short int x[3] = {10, 20, 30}; short int *p = &x; cout << *p << endl; // x[0], p[0] cout << *(p+1) << endl; // x[1], p[1] cout << *(p+2) << endl; // x[2], p[2]



5. 이중 포인터 (double pointer) 포인터의 포인터 , 포인터 변수의 주소를 저장

int x; int *p = &x; int **pp = &p; cout << *p << endl; // x cout << *pp << endl; // p cout << **pp << endl; // *p, x



6. 포인터 배열 (array of pointer) 포인터가 요소인 배열

int *ary[10]; // 10 개의 int * 를 요소로 가지는 배열 // ary[0] 는 int * 자료의 첫 번째 요소 // ary[1] 는 int * 자료의 두 번째 요소 … // ary[9] 는 int * 자료의 마지막 요소



7. 배열 포인터 (pointer to array) 배열의 주소를 저장하는 포인터

int (*p)[10]; // int[10] 의 배열을 가리키는 포인터를 저장하는 변수 int ary[4][10]; p = ary; // ary 의 시작 주소를 저장 // *p 는 ary[0] 의 1 차원 배열을 가리킴 // *(p+1) 은 ary[1] 의 1 차원 배열을 가리킴 , p[1] 과 동일 cout << (*p)[5] << endl; // ary[0][5] cout << (*(p+2))[3] << endl; // ary[2][3]



int (*p)[10]; // int[10] 의 배열을 가리키는 포인터를 저장하는 변수 int ary[10]; p = &ary; // ary 의 주소를 저장 // *p 는 ary 를 가리킴 cout << (*p)[5] << endl; // ary[5]

int RowSum(int ary1D[], int size) // int RowSum(int *ary1D, int size)

int TotalSum(int ary2D[][5], int size) // int TotalSum(int (*ary2D)[5], int size)



8. 함수 포인터 (function pointer) 함수를 가리키는 포인터

int Fn(int x, double y); int (*fp)(int, double) = Fn; fp(x, y); // Fn(x, y); 와 동일



9. new 연산자 동적 메모리 할당 (dynamic memory allocation) 실행 시간에 메모리 할당 ( 변수 생성 ) 메모리 할당이 실패하면 NULL 반환 (Visual Studio 6.0) 하거나 예외 전달

(Visual Studio 2005)

Visual Studio 2005 에서 메모리 할당이 실패하면 NULL 반환

new(nothrow) 자료형 [크기 ]; new(nothrow) 자료형 ;



10.delete 연산자 new 에 의해 할당된 영역은 지역 변수와 다르게 함수가 종료되더라도

해제되지 않음 new 에 의해 할당된 메모리 공간을 해제


이름공간이름공간

#include <iostream> using namespace std; namespace A { int data; } namespace B { int data; } int main() { A::data = 1; // A 이름공간의 전역 변수 data B::data = 2; // B 이름공간의 전역 변수 data cout << A::data << endl; cout << B::data << endl; return 0; }


예외 처리예외 처리 (1)(1)

bool FileOpen() { ifstream fs; try { fs.open("ex.txt"); if(!fs) throw false; } catch(bool &ex) { return false; } // 파일 처리 return true; }



try { FileOpen(); } catch(bool &ex) { // 파일 열기 실패 예외 처리 }

void FileOpen() { ifstream fs; fs.open("ex.txt"); if(!fs) throw false; // 파일 처리 }




고급 입출력고급 입출력 (1)(1)



1. 파일 열기

#include <fstream> using namespace std; … ifstream ifs; // 객체 생성 ifs.open(" 파일이름 "); // 파일 열기 … // 파일 입력 작업 ifs.close(); // 파일 닫기



2. 파일 열기 설정 open 의 두 번째 인수로 지정

플래그 기능

ios::in 읽기 모드

ios::out 쓰기 모드

ios::ate 위치를 파일 끝으로 이동 (at end)

ios::app 파일의 마지막에 추가 기록 (append)

ios::trunc 파일이 있으면 지우고 다시 생성 (truncate)

ios::nocreate 다시 생성하지 않음 ( 파일이 존재하지 않으면 열기 실패 )

ios::noreplace 파일을 대체하지 않음 ( 파일이 존재하면 열기 실패 )

ios::binary 이진 파일 모드

ifstream ifs(" 파일이름 "); // 객체 생성 , 파일 열기 … // 파일 입력 ifs.close(); // 파일 닫기



3. 텍스트 파일과 이진 파일 텍스트 파일 (text file)

모든 자료를 문자형으로 변환하여 저장한 파일

이진 파일 (binary file) 자료를 메모리에 저장된 형식 그대로 저장하나 파일



4. 텍스트 파일 입출력

#include <fstream> using namespace std; …

int x; ifstream ifs; // 객체 생성 ifs.open(" 파일이름 "); // 파일 열기 ifs >> x; // x 를 텍스트 방식으로 읽어 오기 ifs.close(); // 파일 닫기

…

ofstream ofs; // 객체 생성 ofs.open(" 파일이름 "); // 파일 열기 ofs << x << '\t' << "C++"; // x, '\t', "C++" 를 텍스트 방식으로 쓰기

ofs.close(); // 파일 닫기



5. 이진 파일 출력

6. 입출력 조작자

이름 설명 (범위 )

dec 십진수로 출력 ( 계속 )

oct 8 진수로 출력 ( 계속 )

hex 16 진수로 출력 ( 계속 )

fixed 고정 소수점 형식으로 출력 ( 계속 )

scientific 부동 소수점 형식 ( 지수형 ) 으로 출력 ( 계속 )



이름 설명 (범위 )

showpoint 소수점 표시 ( 계속 )

showpos 양수에 대해서 + 기호 표시 ( 계속 )

showbase 진법을 표시 ( 계속 )

setw(n) 출력 폭 지정 ( 한 번 ), n 은 정수

setprecision(n) 유효 자리 수 지정 ( 계속 ), n 은 정수

setfill(ch) 빈자리 채움 ( 계속 ), ch 는 문자형

left 왼쪽 정렬 ( 계속 )

right 오른쪽 정렬 ( 계속 )

internal 부호 / 진법과 숫치를 양쪽 정렬 ( 계속 )

boolalpha 불형 자료를 bool/false 로 출력 ( 계속 )

flush 버퍼의 내용을 출력 ( 한 번 )



7. 입출력 멤버 함수

플래그 기능

setf 입출력 형식의 플래그 설정

unsetf 입출력 형식의 플래그 해제

width 출력 폭 지정

fill 빈자리 채움

precision 유효 자리 수 지정

get 문자형 자료 입력

put 문자형 자료 출력

good 오류 비트 없음

eof 파일의 끝 (end of file) 에 도달

fail 입출력 오류 (EOF 제외 ) 있음

bad 심각한 입출력 오류 있음



setf, unsetf

플래그 기능

tellg 입력 스트림 위치 추출

tellp 출력 스트림 위치 추출

seekg 입력 스트림 위치 지정

seekp 출력 스트림 위치 지정

clear 오류 비트 삭제

ignore 버퍼 내용 삭제



플래그 기능 마스크ios::skipws 입력에서 백색 공백 (white space) 무시

ios::left 왼쪽 정렬 ios::adjustfield

ios::right 오른쪽 정렬 ios::adjustfield

ios::internal 부호나 기수를 왼쪽에 자료는 오른쪽 정렬 ios::adjustfield

ios::dec 십진수 출력 ios::basefield

ios::oct 8 진수 출력 ios::basefield

ios::hex 16 진수 출력 ios::basefield

ios::showbase 기수 표시

ios::showpoint 소수점 표시

ios::uppercase 16 진수의 A F∼ 를 대문자 출력

ios::showpos 양수에 대해서 + 기호 표시

ios::scientific 부동 소수점 형식 ( 지수형 ) 으로 출력 ios::floatfield

ios::fixed 고정 소수점 형식으로 출력 ios::floatfield

ios::unitbuf 삽입 후 스트림의 버퍼 출력

ios::stdio 삽입 후 stdout 과 stderr 의 버퍼 출력



width, fill, precision

get, put



good, eof, fail, bad

tellg, tellp, seekg, seekp



clear, ignore

#include <iostream> using namespace std; int main() { int num; cout << "Input: "; while(!(cin >> num)) cout << "Input: "; cout << num; return 0; }



… #include <limits> … int main() { int num; char aCh; cout << "Input: "; while(!(cin >> num)) { cin.clear(); while(cin.get(aCh) && aCh != '\n'); // 윗 줄과 동일 기능 // cin.ignore(numeric_limits<streamsize>::max(), '\n'); cout << "Input: "; } cout << num; … }


프로그래밍 연습프로그래밍 연습 (1)(1)

1. 2 차 방정식의 실근을 계산// 2 차 방정식의 근을 구하는 함수#include <iostream> #include <cmath>using namespace std; bool Root(double a, double b, double c, double &x1, double &x2) {

double D = b*b - 4.*a*c; // 판별식if(D < 0) return 0; // 허근

x1 = (-b+sqrt(D))/(2*a); // 두 실근x2 = (-b-sqrt(D))/(2*a);

return true; // 실근 가짐}int main (){

double a, b, c, x1, x2;cin >> a >> b >> c; // 계수 입력if(Root(a, b, c, x1, x2)) // 실근을 가지면 출력

cout << x1 << '\t' << x2 << endl;

return 0;}



2. 마방진

① 첫 번째 수 1 은 첫 행 가운데 열 (0 행 n/2 열 ) 에 삽입한다 .

② 행과 열을 모두 1씩 감소하면서 대각선 방향으로 진행한다 .

③ 만일 행의 위치가 음수라면 마지막 행으로 옮긴다 .

④ 만일 열의 위치가 음수라면 마지막 열로 옮긴다 .

⑤ 옮겨진 위치에 이전의 수가 저장되어 있다면 대각선 방향으로 진행하기

전 (② 의 동작을 수행하기 전 ) 의 위치에서 행만 1 증가한 위치로

수정한다 .

⑥ 지정된 위치에 다음 수를 삽입하고 , n×n 이 삽입될 때까지 ②번으로

돌아가서 반복한다 .





// 마방진#include <iostream>#include <iomanip>using namespace std;#define MAX_SIZE 9int main() {

int i;int size; // 마방진 크기int x, y; // x, y 좌표 (우 -x 증가 , 하 -y 증가 )// x, y 좌표 저장 - 이동 위치에 다른 값이 채워진 경우에// 이동 전의 좌표 아래 위치로 옮기기 위하여 이동 전의 좌표 저장int saveX, saveY;int magic[MAX_SIZE][MAX_SIZE];cout << "Size: ";cin >> size; // 마방진 크기 입력

// 크기가 짝수 또는 3 보다 작거나 MAX_SIZE 보다 크면 종료if(size%2 == 0 || size < 3 || size > MAX_SIZE)

return 0;

code 1/3



// 0 으로 초기화for(y = 0 ; y < size ; y++)

for(x = 0 ; x < size ; x++)magic[y][x] = 0;

saveX = size/2;saveY = 0; // 초기 위치 결정 - 1 행 가운데 열

magic[saveY][saveX] = 1;for(i = 2 ; i <= size*size ; i++) {

// 좌 , 상 위치x = saveX-1; y = saveY-1;// 좌표가 음수이면 최대값으로if(x < 0) x = size-1;if(y < 0) y = size-1;// 다른 값이 채워져 있으면 이동 전의 좌표의 아래로if(magic[y][x] != 0) {

x = saveX; y = saveY+1;}// count 값 할당magic[y][x] = i;// 좌표 저장saveX = x; saveY = y;

}

code 2/3



// 출력for(y = 0 ; y < size ; y++){

for(x = 0 ; x < size ; x++)cout << setw(4) << magic[y][x];

cout << endl;}

return 0;}

code 3/3



3. 스택 (Stack) 먼저 입력된 자료가 가장 나중에 출력되는 자료 구조 (FILO: First In Last

Out)



스택에서 필요한 자료 자료들을 저장할 배열 ( 자료형에 따라서 변경 ) 현재 저장된 위치를 알려줄 포인터 (int)

정수형 자료를 저장할 스택– int data[100];

– int stackPointer;

두 개의 자료가 하나의 묶음으로 표현되어야 하므로 구조체 사용

#define MAX 10struct Stack { int data[MAX]; int stackPointer;};



스택의 동작을 관리할 함수 스택을 초기화 InitStack

– stackPointer -1

스택에 자료 추가 Push

– 추가할 수 있는가 ?

– stackPointer stackPointer + 1

– 자료 추가

스택에서 자료 추출 Pop

– 추출할 자료가 있는가 ?

– 자료 추출– stackPointer stackPointer - 1



void InitStack(Stack &s) { s.stackPointer = -1;}

bool Push(Stack &s, int data) { if(s.stackPointer >= MAX-1) return false; s.data[++s.stackPointer] = data; return true;}

bool Push(Stack &s, int &data) { if(s.stackPointer <= -1) return false; data = s.data[s.stackPointer--]; return true;}



void InitStack(Stack *pS) { pS->stackPointer = -1;}

bool Push(Stack *pS, int data) { if(pS->stackPointer >= MAX-1) return false; pS->data[++pS->stackPointer] = data; return true;}

bool Push(Stack *pS, int *pData) { if(pS->stackPointer <= -1) return false; *pData = pS->data[pS->stackPointer--]; return true;}

만일 이와 같은 동작의 함수를 구조체의 멤버로 포함한다면 C++ 의 구조체 / 클래스만일 data 의 자료형을 다양하게 사용하고 싶다면 C++ 의 템플릿



4. 정렬 (sort) 순서에 맞게 배열 오름차순 / 내림차순 선택 정렬 , 삽입 정렬 , 버블 정렬

선택 정렬 (selection sort) 순서에 맞는 값을 찾아서 정렬

삽입 정렬 (insertion sort) 순차적으로 자료들을 정렬된 자료의 순서에 맞게 삽입

버블 정렬 (bubble sort) 인접한 두 자료를 비교하여 가장 앞선 자료를 순에서 맞게 정렬해 나감



버블 정렬



void BubbleSort(int *list, int size) { int temp; int i, k;

for(k = 0 ; k < size-1 ; k++) { for(i = size-1 ; i > k ; i--) { if(list[i-1] > list[i]) { temp = list[i-1]; list[i-1] = list[i]; list[i] = temp; } } }}



선택 정렬과 삽입 정렬



void SelectionSort(int *list, int size) { int temp; int sel; int i, k;

for(k = 0 ; k < size-1 ; k++) { sel = k; for(i = k+1 ; i < size ; i++) if(list[i] < list[sel]) sel = i;

if(sel != k) { temp = list[sel]; list[sel] = list[k]; list[k] = temp; } }}



void InsertionSort(int *list, int size) { int ins; int i, k;

for(k = 1 ; k < size ; k++) { ins = list[k]; for(i = k-1 ; i >= 0 && list[i] > ins ; i--) list[i+1] = list[i];

list[i+1] = ins; }}



5. 행렬 연산 double A[2][3];

2×3 행렬 또는 3×2 행렬 표현 일반적으로 2×3 행렬 표현 , [ 행 ][ 열 ]

행렬의 동적 메모리 할당

double **AllocMatrix(int nRow, int nCol) { double **temp; int y;

temp = new double*[nRow]; for(y = 0 ; y < nRow ; y++) temp[y] = new double[nCol];

return temp;}



행렬의 할당된 메모리 해제

void FreeMatrix(double **matrix, int nRow) { int y;

for(y = 0 ; y < nRow ; y++) delete [] matrix[y];

delete [] matrix;}



행렬 덧셈 1

double **AddMatrix(double **A, double **B, int nRow, int nCol) { int x, y; double **C;

C = AllocMatrix(nRow, nCol);

for(y = 0 ; y < nRow ; y++) for(x = 0 ; x < nCol ; x++) C[y][x] = A[y][x] + B[y][x];

return C;}



행렬 덧셈 2

void AddMatrix(double **A, double **B, int nRow, int nCol, double **C) { int x, y;

for(y = 0 ; y < nRow ; y++) for(x = 0 ; x < nCol ; x++) C[y][x] = A[y][x] + B[y][x];}



행렬 곱셈

double **ProductMatrix(double **A, int nRowA, int nColA, double **B, int nRowB, int nColB) { if(nColA != nRowB) return NULL; int x, y, i; double **C;

C = AllocMatrix(nRowA, nColB); for(y = 0 ; y < nRowA ; y++) for(x = 0 ; x < nColB ; x++) { C[y][x] = 0; for(i = 0 ; i < nColA ; i++) C[y][x] += A[y][i] + B[i][x]; }

return C;}



void PrintMatrix(double **A, int nRow, int nCol) { int x, y;

for(y = 0 ; y < nRow ; y++) { for(x = 0 ; x < nCol ; x++) cout << setw(7) << fixed << setprecision(3) << A[y][x]; cout << endl; }}

void InitMatrix(double **A, int nRow, int nCol) { int x, y;

for(y = 0 ; y < nRow ; y++) for(x = 0 ; x < nCol ; x++) A[y][x] = (double)rand()/RAND_MAX-0.5;}



int main() { double **A, **B, **C; int nRow = 3, nCol = 4;

A = AllocMatrix(nRow, nCol); B = AllocMatrix(nRow, nCol);

srand((unsigned int)time(NULL)); InitMatrix(A, nRow, nCol); InitMatrix(B, nRow, nCol);

C = AddMatrix(A, B, nRow, nCol);

PrintMatrix(A, nRow, nCol); cout << endl; PrintMatrix(B, nRow, nCol); cout << endl; PrintMatrix(C, nRow, nCol); cout << endl;

FreeMatrix(A, nRow); FreeMatrix(B, nRow); FreeMatrix(C, nRow);

return 0;}



int main() { double **A, **B, **C; int nRow = 3, nCol = 4;

A = AllocMatrix(nRow, nCol); B = AllocMatrix(nRow, nCol); C = AllocMatrix(nRow, nCol);

srand((unsigned int)time(NULL)); InitMatrix(A, nRow, nCol); InitMatrix(B, nRow, nCol);

AddMatrix(A, B, nRow, nCol, C);

PrintMatrix(A, nRow, nCol); cout << endl; PrintMatrix(B, nRow, nCol); cout << endl; PrintMatrix(C, nRow, nCol); cout << endl;

FreeMatrix(A, nRow); FreeMatrix(B, nRow); FreeMatrix(C, nRow);

return 0;}



int main() { double **A, **B, **C; int nRowA = 3, nColA = 4; int nRowB = 4, nColB = 2;

A = AllocMatrix(nRowA, nColA); B = AllocMatrix(nRowB, nColB);

srand((unsigned int)time(NULL)); InitMatrix(A, nRowA, nColA); InitMatrix(B, nRowB, nColB);

C = ProductMatrix(A, nRowA, nColA, B, nRowB, nColB);

PrintMatrix(A, nRowA, nColA); cout << endl; PrintMatrix(B, nRowB, nColB); cout << endl; if(C) PrintMatrix(C, nRowA, nColB); cout << endl;

FreeMatrix(A, nRowA); FreeMatrix(B, nRowB); if(C) FreeMatrix(C, nRowA); return 0;}



11 12

21 22

a aA

a a

11 22 12 21A a a a a

11 12 13

21 22 23

31 32 33

a a a

A a a a

a a a

11 22 33 12 23 31 13 21 32

13 22 31 12 21 33 11 23 32

A a a a a a a a a a

a a a a a a a a a

11 22 33 11 23 32 12 23 31 12 21 33 13 21 32 13 22 31

11 22 33 23 32 12 23 31 21 33 13 21 32 22 31

11 22 33 23 32 12 21 33 23 31 13 21 32 22 31

( ) ( ) ( )

( ) ( ) ( )

A a a a a a a a a a a a a a a a a a a

a a a a a a a a a a a a a a a

a a a a a a a a a a a a a a a



double GetDeterminant(double **A, int nRow, int nCol) { if(nRow != nCol) return 0; int x, y, k; double **S; double sign, Determinant;

if(nRow == 2) { Determinant = A[0][0] * A[1][1] - A[0][1] * A[1][0]; } else if(nRow > 2) { sign = 1.; Determinant = 0.; S = AllocMatrix(nRow-1, nCol-1);

for(k = 0; k < nCol ; k++) { for(y = 0 ; y < nRow-1 ; y++) { for(x = 0 ; x < nCol-1 ; x++) { if(x < k) S[y][x] = A[y+1][x]; else S[y][x] = A[y+1][x+1]; } } Determinant += sign * A[0][k] * GetDeterminant(S, nRow-1, nCol-1); sign *= -1.; } FreeMatrix(S, nRow-1); } return Determinant;}



int main() { double **A, **B; int nRowA = 2, nColA = 2; int nRowB = 3, nColB = 3;

A = AllocMatrix(nRowA, nColA); B = AllocMatrix(nRowB, nColB);

srand((unsigned int)time(NULL)); InitMatrix(A, nRowA, nColA); InitMatrix(B, nRowB, nColB);

PrintMatrix(A, nRowA, nColA); cout << GetDeterminant(A, nRowA, nColA) << endl; PrintMatrix(B, nRowB, nColB); cout << GetDeterminant(B, nRowB, nColB) << endl;

FreeMatrix(A, nRowA); FreeMatrix(B, nRowB);

return 0;}

Documents

고급객체지향프로그래밍 객체 지향으로 접근하는 C++ 프로그래밍