JW

클라우드 기초 15주차

wlsn — Thu, 12 Dec 2024 16:44:34 +0900

IT 인프라 관련 기술
하드웨어
운영체제
가상화기술
네트워크
클라우드

직렬/병렬
  • 서버 내부에서의 처리
  • 멀티 프로세스 : 다수의 웹서버 데몬(httpd)을 실행
  • 멀티 스레드 : 하나의 프로세스 안에 다수의 스레드를 이용해 병렬화
프로세스(독립적)/스레드(할당받아서 사용함)
작업관리자에서 하나를 껐을 때 하나만 꺼지는 것이 프로세스
메모리를 공유해 하나를 껐을 때 다같이 꺼지는 것이 스레드

동기/비동기
• 동기 처리
  • 서버가 일을 마칠때까지 기다림
  • 설계가 간단하고 직관적
  • 결과가 있을 때까지 아무것도 못하고 대기
  • (예) 웹페이지를 새로고침

• 비동기 처리
  • 서버에게 일을 맡기고 다른 일을 하고 때가 되면 응답 받음
  • 동기보다 복잡
  • 자원을 효율적으로 사용할 수 있음
  • (예) 웹페이지 새로고침 하지 않고 데이터 로드(댓글 영역만 업데이트)

큐
• Queue(큐) : 대기 행렬로서 FIFO(First-In-First-Out) 구조를 가짐
  • 사용 사례
  • CPU 처리를 기다리고 있는 프로세스나 스레드 행렬
  • 프린터 출력을 위한 대기열
  • 네트워크의 품질(QoS)을 높이기 위해 우선순위 큐 사용
  • cf) Stack(스택) : Last-In-First-Out 구조

• 연결 리스트
  • 크기가 가변적
  • 메모리 공간에 불연속적으로 데이터 저장
  • 다음 항목의 주소를 저장 & 선으로 연결한 구조
  • 탐색은 느리나, 데이터 추가, 삭제가 빠름
메모리 관점에서 찾아봐야한다.

캐시
• 캐시
  • 사용 빈도가 높은 데이터를 고속으로 접근할 수 있도록 조치하는 것

• 브라우저에서 요청한 페이지가 먼저 캐시에 저장되어 있는지 확인
  • 캐시에 있으면 빠른 응답(cache hit)

• 캐시에 없으면 메모리로부터 데이터를 가져오고 재사용을 위해 캐시에 저장(cache miss)
  • 보통 CPU와 메모리 사이의 속도를 조절하기 위해 사용하나,
웹서비스에서 브라우저와 웹서버 간의 속도를 조절할 때도 사용

레지스터 -> 캐시 -> 메모리 -> 하드디스크

베타적 제어
• 병렬처리 환경에서 하나의 자원을 공유하는 상황에 발생
  • 공유자원(CPU, 메모리 등)에 동시 접근 시 장애 발생
  • 배타적 제어 처리 부분은 병목현상 발생
  • 두 개 이상의 프로세스/스레드가 공유자원에 동시에 접근 불가
  • 사례
  • DMBS에 사용되는 배타적 제어
With 배타적 제어 공유 데이터를 일관성 있게 유지(장점) / 병렬 처리 불가(단점)
W/O 배타적 제어 병렬처리로 빠르게 처리(장점) / 데이터 불일치 발생(공유 데이터 동시 접속)(단점)

인터럽트
• 프로세스 실행 중 예상하지 못한 상황이 발생했을 때, 그 일을 먼저 처리 후 원래 작업으로 복귀

• 외부 인터럽트
  • 입출력 장치 : 키보드, 마우스와 같은 입출력 장치의 입력 처리
  • 타이머 : 일정 시간 간격으로 CPU에 인터럽트 요청

• 내부 인터럽트
  • 하드웨어의 고장(0으로 나누기)
  • 실행할 수 없는 명령어
  • 명령어 실행 오류
  • 사용 권한 위배

폴링
• 일정한 주기로 서버와 응답을 주고 받는 방식

• HTTP는 지속적 연결(Persistent Connection)이 불가능, 주기적으로 서버에 요청을 보내 업데이트!

• 폴링의 주기가 짧으면 서버에 오버헤드(부담) 증가, 주기가 길면 실시간성이 떨어짐

• cf) 웹훅 : 서버에서 어떠한 작업이 수행되었을 때 해당 작업이 발생했다고 HTTP POST 방식으로 알림
  • (예) 특정 이벤트(사용자 로그인)가 발생했을 때 알림

가용성 향상(이중화)
• 이중화란?
  • 시스템의 장애를 대비하는 등 안정성을 강화하기 위해 같은 시스템을 두 개 이상 설치하고, 시스템 장애 발생시 정상 시스템으로 전환하도록 만든 구조

• 안정성
  • 시스템이 일정한 시간동안 오류 없이 동작하는 능력 = 고가용성(High Availability)
  • 가용성(Availability) : 시스템이 서비스를 요청 받았을 때, 서비스를 제공할 수 있는 능력

이중화 대상
• 전원, 장치 등의 이중화
  • 독립적으로 운영되는 복수의 전원 탭 연결, UPS(정전 시에 애용하는 대규모 충전지) 활용

• (WEB/WAS) 서버 이중화
  • 물리적 서버나 가상 서버를 복수로 구성하여 한 서버가 장애가 발생하더라도 다른 서버가 서비스 제공

• 네트워크 이중화
  • 네트워크 인터페이스 카드(NIC)를 이중화 하여 카드 장애 및 포트 장애에 대응
  • 네트워크 장비의 장애를 대비한 이중화 (예) 같은 일을 하는 L2 혹은 L3 스위치 2개 연결

• 저장소 이중화
  • HDD 이중화 혹은 RAID 구성을 통해 디스크 이중화

• 데이터 센터 이중화
  • 자연 재해를 대비해 데이터 센터 자체를 이중화

이중화 구현 기술
• 로드 밸런싱
  • L4 스위치 등을 이용해 트래픽을 여러 서버에 분산

• 클러스터링
  • 여러 서버를 하나의 시스템처럼 동작하게 만드는 기술

• 데이터 복제
  • Active 서버와 Standby 서버 간의 데이터 동기화

• 하트비트(Heartbeat) 모니터링
  • 시스템이 살아있는지 확인
  • 서버들 간에 주기적으로 상태를 확인하여 장애 감지
  • (예) 에이전트가 60초 간격으로 하트비트 메시지 전송, 정해진 시간에 하트비트 메시지가 오지 않으면 경고 및 추가 조치

성능향상
• 성능 문제의 원인 : 응답속도, 처리량

• 응답속도(Response) : 서비스 요청에 대한 응답 속도 (예) 버퍼링
  • 응답 지연이 발생 지점 확인
  • 네트워크 성능 확인

• 처리량(Throughput) : 단위 시간 당 처리된 데이터의 양 (예) bps, Mbps
  • 컴퓨팅 리소스(CPU, 메모리 등)의 처리 능력 확인
  • 네트워크 대역폭 확인
• 병목현상(bottleneck) : 병의 목이 좁아 흐르는 수량이 제한되는 성질
  • 해결 : 원인을 파악해 시스템 성능을 높이거나(Scale Up) 병렬 처리할 수 있도록 수를 늘림(Scale Out)

위치별 병목현상
• CPU 병목 현상
  • CPU를 이용하기 위해 대기 행렬이 발생(큐에 데이터가 쌓임)
  • CPU 응답이 느림
  ※ CPU 사용률이 100%라고 해서 병목현상이 발생한다는 것은 아님

• 메모리 병목 현상
  • 메모리 영역 고갈
  • 동일 영역의 경합(공유 메모리에 다수가 접근)

• 디스크 I/O 병목현상
  • HDD에 읽기/쓰기 과정에서의 병목

• 네트워크 I/O 병목현상
  • 모든 트래픽을 한 개의 게이트웨이에서 처리하면서 병목

• 애플리케이션 병목현상
  • 알고리즘의 문제로 처리량 혹은 응답속도가 낮음
  • 비효율적인 데이터베이스 접근

클라우드 컴퓨팅의 탄생
• 물리 서버를 사용하면서 비효율 발생으로 가상화 기술 탄생
  • 자원(비용)의 비효율
    • 하나의 서버에서는 하나의 운영체제와 애플리케이션을 설치/운용
    • 하드웨어는 급속히 발전함에 따라 소프트웨어 요구사항을 상회
    • 물리 서버 자원을 효율적으로 활용하기 위한 요구 등장
    (예) 자원활용도가 너무 낮더라도 별도의 서버 구축 → 가상화를 통해 자원 분배

• 확장성
  • 비정기적인 트래픽(수강신청 등)에 대비하기 위해 충분한 서버 구축 필요
  ➔ 서버의 확장 및 축소에 리소스가 많이 투입됨 (예) 서버 구입, 환경 구성(인터넷 연결, OS/app 설치 등)

• 유지보수
  • 서버 장애시 서버 교체를 위해, 서버를 OFF 하고 교체하면 서비스 중단 발생

• 가상화 기술의 등장으로 자원을 효율적으로 사용할 수 있게 됨

가상화 기술
• 가상화(Virtualization)
  • 하드웨어 리소스(CPU, 메모리, 스토리지)를 논리적으로 다루는 기술
  • 서버 가상화, 네트워크 가상화, 스토리지 가상화

• 서버 가상화 장점
  • 물리 서버 하나의 리소스를 여러 개의 서버 환경으로 할당 → 각각 OS 및 app 실행
  • 물리 서버 수를 줄여 공간 절약 및 비용 절감
  • 가상 서버 중 하나가 장애(바이러스 등)가 발생하더라도 다른 가상 서버에 영향 X

• 서버 가상화 기술
하이퍼바이저형
APP / APP
게스트OS / 게스트 OS
하이퍼바이저
하드웨어

호스트 OS형
APP / APP
게스트OS / 게스트OS
호스트 형 가상화 소프트웨어
호스트OS
하드웨어

컨테이너형
APP / APP
실행환경 / 실행환경
컨테이너 관리 소프트웨어
호스트OS
하드웨어

하이퍼바이저형은 호스트OS가 없고 호스트OS, 컨테이너형은 호스트OS가 깔려있다.

컨테이너 기술
• 컨테이너
  • 애플리케이션과 그 실행에 필요한 모든 종속성(라이브러리, 바이너리 등)을 하나로 패키징한 기술
  cf. 서버 가상화는 하드웨어 환경을 통째로 가상화

• 등장 배경
  • 환경 일관성 : 내컴퓨터에서는 잘 작동 했었는데….
  • 클라우드 컴퓨팅 확산 : 신속한 배포와 확장성
  • 마이크로 서비스 아키텍처(MSA) : 작은 단위의 서비스들을 독립적으로 배포/관리

• 특징
  • 가상 서버보다 가상화 오버헤드가 적어 빠르게 기동/정지 가능
  • 하드웨어 리소스 사용이 적어 1대의 물리 서버에 많은 컨테이너 동작 가능
  • 컨테이너 단위로 패키징 되어 클라우드 간 복제 및 이식성 우수

• 대표 컨테이너 타입 가상화 소프트웨어 = Docker
• 컨테이너 타입 가상화 소프트웨어 운영 관리 도구 = Kubernetes(K8S)

하이퍼바이저형
장점 : 가상서버마다 OS 선택가능, 가상서버들을 완전히 분리, 하나의 가상서버가 사이버공격을 받아도 다른 가상서버에 영향을 못미침
단점 : 가상서버마다 OS가 필요해 CPU,메모리,스토리지 등의 하드웨어 리소스 사용량이 많음, 가상서버의 부팅시간이 많이걸림

컨테이너형
장점 : 다른 컨테이너에 복사하거나 마이그레이션하기 쉬움, 가상화 환경 위에서 별도의 OS를 동작시킬 필요가 없어 하드웨어 리소스가 적고 부팅이 빠름
단점 : 호스트OS와 컨테이너는 커널을 공유(Linux 커널에서 window 컨테이너 동작 불가능), 하나의 호스트OS가 여러개의 컨테이너를 동작 시키므로 한 컨테이너가 사이버 공격을 받으면 다른 컨테이너도 위험에 노출됨

클라우드 컴퓨팅이란?
정의 : 클라우드 컴퓨팅이란, 공유 구성이 가능한 컴퓨팅 리소스(네트워크, 서버, 스토리지, 애플리케이션 서비스)의 통합을 통해 어디서나 간편하게, 요청에 따라 네트워크를 통해 접근하는 것을 가능하게 하는 모델이다.
이는 최소한의 이용 절차 또는 서비스 공급자의 상호 작용을 통해, 신속히 할당되어 제공된다.

클라우드는 그릇(기반기술)
• 그릇 : 클라우드 사업자 (AWS, Azure, GCP, …)
• 음식 : AI, IoT, 로봇, 블록체인, 양자, 위성, …

• 식탁에 다양한 음식들이 각각의 그릇에 담겨 사용자에게
제공됨
→ 사용자는 클라우드 환경에서 동작하는 각종 서비스를
유연하게 사용할 수 있음
  • 개인 그릇, 공용 그릇을 구별(public/private)
  • 각 그릇은 다양한 음식을 담을 수 있음(다양한 서비스)
  • 1개 식탁에 1개 이상의 그릇을 셋팅 할 수 있음 (multi/hybrid cloud)
  • 다른 그릇의 소스를 찍어 먹을 수 있음(상호운용성)

SaaS(Software as a Service)
• 업무에서 사용하는 SW의 기능을 필요한 만큼 서비스로 제공
• 하나의 서버를 여러 기업에서 공유하는 멀티 테넌트 방식
• 사용자 계정을 마련하면 서비스 바로 이용
• 스마트폰, 태블릿 등의 다양한 기기로 접속 가능

PaaS(Platform as a Service)
• 기업의 애플리케이션 실행 환경 및 애플리케이션 개발 환경을 서비스로 제공
• 애플리케이션 실행 환경이나 데이터베이스 등이 미리 제공
• 자사에서 개발한 응용 프로그램을 가동할 수 있음
• 서버 및 미들웨어의 상세 설정은 불가능

IaaS(Infrastructure as a Service)
• CPU나 하드웨어 등의 컴퓨팅 리소스를 네트워크를 통해 서비스로 제공
• 대표 서비스: 가상 서버, 온라인 스토리지
• 하드웨어 자원을 소프트웨어적으로 나누어 사용자에게 제공(자유로운 스케일 업/다운)
• 사용량에 따른 종량제 혹은 월정액제
• (예) 프로모션 진행 시 일시적으로 컴퓨터 리소스를 많이 빌려 사용하고, 종료되면 리소스 감축
• Amazon Elastic Compute Cloud(EC2)

클라우드 이용모델
• 온프레미스(on-premise)
  • 회사 내에 자체적으로 데이터 센터를 보유하고 시스템 구축에서 운용까지 직접 수행하는 형태
  • 장점 : 높은 품질 & 보안
  • 단점 : 하드웨어 리소스(CPU, 메모리 등)를 구축하는 초기 비용 발생,

• 퍼블릭 클라우드(Public Cloud)
  • AWS, GCP, Azure와 같은 클라우드 사업자가 시스템을 구축해 불특정 다수에게 서비스 제공
  • 장점 : 하드웨어 투자 비용이 낮음, 필요한 자원을 빌려씀
  • 단점 : 사용량이 많아지면 온프레미스 환경보다 더 많은 비용이 발생할 수 있음

• 프라이빗 클라우드(Private Cloud)
  • 클라우드 서비스 제공자가 기업의 전용 데이터 센터 환경 구축 제공
  • 장점 : 높은 보안성
  • 단점 : 공용 클라우드보다 초기비용이 많이들고, 전문인력이 필요하며 유지보수 비용이 높음
• 하이브리드 클라우드(Hybrid Cloud)
  • 퍼블릭 클라우드 + 프라이빗 클라우드

• 커뮤니티 클라우드(Community Cloud)
  • 공통의 관심사(보안, 규정준수, 관할권 등)를 가진 특정 목적의 커뮤니티를 공유하는 클라우드

C++과 함께하는 우주 탐험

wlsn — Tue, 10 Dec 2024 13:15:19 +0900

1. 우주선의 준비

이 우주선은 다양한 도구들을 갖추고 있었고, 마치 가상 함수처럼 하나의 이름으로 여러 수단과 방법을 제공하는 형태의 도구들이었습니다.

2. 우주정거장과의 연결

탐사대는 우주정거장과의 연결을 위해 바인딩을 설정했습니다. 이는 우주선과 정거장이 어떻게 결합되어 서로 협력할 수 있는지를 결정합니다.

3. 산소의 공유

우주선과 우주정거장은 static 멤버 변수를 통해 모든 탐사대원이 공유하는 산소를 관리했습니다. 이 산소는 탐사대의 공동으로 사용하는 자원이었습니다.

4. 이동 도구의 상속

탐사대는 우주정거장에서 받은 이동 도구를 사용했습니다. 이 도구들은 부모로부터 자식에게 속성과 행동이 물려지는 상속의 개념처럼 작용했습니다.

5. 출발 준비

탐사대는 필요한 물품들을 정리했습니다. 이 과정은 마치 생성자가 객체를 초기화하는 것과 같습니다.

6. 임무 내용 메모

우주선 안에는 각 탐사대원이 맡은 임무 내용을 메모할 수 있는 공간이 있었습니다. 이 메모는 함수 중첩처럼, 임무 내용을 기록하면서도 각 페이지와 독립적으로 생각할 수 있는 구조였습니다.

7. 식사 시간

우주선에서 식사할 때, 특별한 주문이 없다면 정해진 음식이 제공되었습니다. 이는 디폴트 인자의 개념처럼, 기본값이 자동으로 적용되는 상황이었습니다.

8. 우주선의 속도

우주선은 const 객체처럼, 한 번 설정된 속도는 변경할 수 없었습니다. 이 안정적인 속도로 탐사대는 안전하게 목적지에 도착할 수 있었습니다.

9. 자기 점검

탐사대원들은 우주선을 수리할 때 this 포인터를 사용하는 것처럼 자신의 상태를 점검했습니다. 각자 자신이 맡은 부분을 세심하게 점검하며 우주선의 안전을 확보했습니다.

10. 상태 점검을 위한 포인터 사용

탐사대는 각 팀원이 맡은 장비의 상태를 점검할 때 포인터를 활용했습니다. 예를 들어, 한 팀원이 특정 장비의 상태를 확인하기 위해 포인터를 사용하여 해당 장비의 메모리 주소를 참조했습니다.

11. 탐사대원 정보 기록

탐사대원들은 서로의 정보를 쉽게 확인하기 위해 struct방식을 사용했습니다. 이름, 나이, 역할을 카드에 함께 적어 정리했습니다.

12. 조직의 관리

탐사대는 여러 팀으로 나뉘어 있었고, 각 팀은 namespace를 활용하여 서로를 구분했습니다.

13. 민수의 복제

탐사 중, 민수라는 탐사대원이 발견되었습니다. 그는 템플릿의 개념처럼, 하나의 틀로 다양한 데이터 타입의 존재를 보여주었습니다.

14. 임무의 마무리

모든 임무가 끝난 후, 탐사대는 외계 행성에서 지구로 돌아오기 전에 모든 물품을 정리하고 청소했습니다. 이는 소멸자처럼, 떠나기 전 청소하는 과정이었습니다.

클라우드 기초 14주차

wlsn — Thu, 5 Dec 2024 16:41:20 +0900

아키텍처 - 클라이언트 서버시스템
- 클라이언트와 서버간의 상호 통신
- Thin Client : 중요 데이터 처리는 서버에 맡기고 클라이언트는 단순한 역할만 수행
- Fat Client : 중요 데이터 처리는 클라이언트에서 담당하고, 서버는 단순히 데이터 취합 및 전달 역할 수행

예시1) 게임에서 방장 컴퓨터 사양이 낮으면 게임 전체가 느려짐

   예시2) 주식 프로그램은 차트표기, 주가 흐름분석 등을 클라이언트에서, 필요한 주가 데이터는 서버에서 취득

아키텍처 - 3계층형 아키텍처
클라이언트 -> 웹서비스 -> 애플리케이션 -> 데이터베이스 순으로 이어짐

프레젠테이션 계층(Presentation)
- 사용자의 입력만 받음
- 웹브라우저 화면을 표시
- Apache, IIS 등
애플리케이션 계층(Application)
- 사용자 요청에 따른 업무(비즈니스 로직) 처리 실시
- ASP, PHP, JSP 등
데이터 계층(Data)
- 애플리케이션 계층의 요청에 따라 데이터 입출력

특징
- 각 계층이 분리되어 있어 효율적임(유지보수, 확장성 등)
- 서버 부하 집중 및 개선
- 클라이언트에서 업데이트가 불필요하며, 웹 브라우저만 있으면 됨
- 구조가 복잡하고, 장애 포인트가 늘어날 수 있음

3계층 네트워크 시스템의 동작(Client Web)
- 웹 브라우저가 http://www.naver.com 요청
- 해당 사이트가 어디에 있는지 이름해석(IP주소를 찾는 과정)
   클라이언트는 IP주소 변환 테이블에 네이버가 있는지 확인하고, 없으면 DNS에 요청
DNS로부터 IP 주소를 획득
- 네이버의 웹 서버에 도착하면 웹 서버 데몬(httpd)프로세스가 요청을 접수함
- 정적 컨텐츠인지 동적 컨텐츠인지 판단
   정적 컨텐츠면 웹 서버에서 직접 응답, 동적컨텐츠면 AP서버로 요청 전달
   정적 컨텐츠 : 실시간으로 변경할 필요가 없는 고정된 데이터(회사 로고, 이미지 등)
   동적 컨텐츠 : 사용자나 상황에 따라 변경되는 데이터(최신 날씨 정보, 장바구니 등)

3계층 네트워크 시스템의 동작(Web Was)
- 웹 서버로부터 요청이 도착
- 스레드가 요청을 받으면 자신이 계산할 수 있는지, DB 접속이 필요한지 판단
- DB 접속이 필요하면 커넥션 풀(connection pool)에 엑세스
   Connection pool : 시간 및 자원 효율을 위해 DB 연결을 미리 여러 개 생성해 두고 필요할 때 사용
   예시) 마치 키와 비슷하다 미리 만들어진 키를 바로 전달받아 사용하고 사용이 완료된 키는 Connection을 통해 반환하는 형태

3계층 네트워크 시스템의 동작(Was DB)
- AP 서버로부터 요청이 도착
- 프로세스가 요청을 접수하고 캐시가 존재하는지 확인
- 캣에 없으면 DBMS를 통해 디스크에 엑세스
   DBMS : 데이터베이스 내의 데이터를 접근할 수 있도록 해주는 소프트웨어(MySQL 등)
- 디스크가 데이터를 반환
- 데이터를 캐시 형태로 저장
   다음번에 빠른 응답을 위해 캐시로 저장
- 결과를 AP서버로 반환

3계층 네트워크 시스템의 동작(DB → Client)
- AP 서버가 DB로부터 데이터 수신
- 스레드가 수신한 데이터로 결과 도출
- 해당 결과를 웹 서버로 반환
- 웹 서버의 프로세스는 해당 결과를 그대로 반환
- 결과가 클라이언트의 웹 브라우저로 반환되어 화면에 표시

프로그램 vs 프로세스 vs 스레드
- 프로그램
   특정 작업을 수행하기 위해 작성된 명령어들의 집합
   하드 디스크와 같은 저장장치에 저장된 상태(메모리에 올라가지 않은 상태)
- 프로세스(Process)
   실행 중인 프로그램
   독립된 메모리 공간(다른 프로세스와 독립적)
   메모리에 적재된 후 CPU 자원을 할당받아 실행
   멀티 프로세스 : 여러 개의 프로그램을 여러 개의 프로세스가 동시에 처리
   예시) 한글,엑셀,PPT 등 동시에 동작
- 스레드(Thread)
   프로세스 내에서 실행되는 작업의 최소의 단위
   프로세스의 자원을 공유
   병렬 처리 가능(multi-thread)
   멀티 스레드 : 하나의 프로그램 내 여러 작업이 동시에 처리
   예시) 한글 프로그램에서 문서작성, 오타검색이 동시에 동작

Process는 OS의 관리 대상이라는 점
OS는 프로세스 전체 목록을 가지고 있으며 이를 Process table이라고도 하는데 Unix 초창기에는 이를 array 형태로 구현이 되어있었다고 한다. 현재는 linked list 형태로 수정되었다.
프로세스를 관리한다는 것은 현재 CPU를 점유할 프로세스를 고르는 "스케줄링"에 관련된 정보와 "State", "메모리 정보", "File Descripter table", "Kernel Stack", "Process ID", "IPC" 등 모두 포함한다.
이 모든 정보를 프로세스 하나당 한개로 묶어서 관리하는 것을 PCB(Process Control Block)이라고 한다.

스탠바이형 아키텍처
- 동일한 작업을 수행하는 물리 서버를 최소 2대 설치하여 고가용성을 높이는 구조
   고가용성(High Availability) : IT 시스템의 장애를 최소화해 100% 상시 접근이 가능한 상태로유지하는 능력
- 서버의 이중화 목적
   부하분산 : 여러 자원이 나누어 처리하여 안정적인 서비스 제공
   장애처리 : 하나의 서버가 장애가 생기더라도 다른 서버에서 서비스 제공
- Active-Active 구조
   L4 스위치 등으로 부하분산하여, 1번서버 & 2번서버가 나누어 처리
- Active-Standby 구조 (Active-Passive)
   1번 서버 동작(Active 상태), 2번 서버 대기(Stand by 상태)
   1번 서버가 장애 발생시, 2번 서버가 즉시 Active 상태로 전환되어 서비스 제공
   페일오버(Failover) : 장애 조치 기능으로 시스템 장애 발생시 다른 시스템으로 대체하여 운영

재해 대책형 아키텍처
- 화재, 지진 등의 재해로부터 대응하기 위한 구조
- 재해복구(Disaster Recovery, DR)
   특정 데이터 센터에서 장애가 발생하면 지리적 위치가 다른 환경에서 업무재개

IT 인프라(HW) - 서버
- 일반 컴퓨터(PC)와 유사
   전원이 이중화 되어 안정적인 전원공급
   CPU, 메모리가 일반 컴퓨터보다 처리용량이 높음
   타워형 서버, 랙마운트형 서버
- 각 컴포넌트는 버스(Bus)로 연결
   버스(Bus) : 서버 내부의 컴포넌트들을 서로 연결하는 회선
   예시) CPU와 메모리의 연결
- PClE(PCI Express)는 외부 장치와 연결되는 버스
- 가상서버(Virtual Machine, VM)
   가상화(Virtualization) 기술을 통해 하드웨어 자원을 여러 개로 분할하여 각각을 개별 서버로 동작
   하이퍼바이저(Hypevisor) : 가상머신 생성 및 삭제 S/W
예시) VMware, VirtualBox 등

IT 인프라(HW) - GPU서버
- GPU(Graphics Processing Unit) 서버는 일반 CPU 서버와 달리 강력한 그래픽 처리 장치를 답재한 서버
- 고성능 컴퓨팅 환경에 필수적으로 활용되고 있음
- 병렬 처리 능력
   수천 개의 코어를 통한 동시 연산 처리
   행렬 연산과 같은 대규모 병렬처리에 최적화
- 활용분야
   인공지능 및 머신러닝
   데이터 사이언스
   3D 렌더링

IT 인프라(HW) - 서버랙
- 하드웨어 장비를 설치하는 장치
- 전면에는 전원버튼, HDD 등이 있음
   손으로 쉽게 HDD 교체 원활
- 서버랙 규격
   폭 : 19인치
   1U : 4.5cm, 2U = 9cm
- 전원선 등 케이블은 랙 뒷면에서 연결

IT 인프라(HW) - 스토리지
- 컴퓨터에 데이터를 저장하는 저장소의 역할
   RAID : 고가용성과 고성능, RAID 0(스트라이핑), RAID(미러링) 등
- 스토리지 종류
   DAS(Direct Attached Storage)
   저장 장치가 호스트에 직접 연결되어 사용 및 관리
   예시) USB 사용 외장하드
NAS(Network ATTached Storage)
   스토리지를 네트워크에 부착하여 사용(데이터 공유 방식)
   확장성, 유연성이 뛰어남, 접속 증가시 성능저하
   SAN(Storage Area Network)
   스토리를 전용 네트워크로 구성하여 사용(고속, 고품질 환경)
   광채널 스위치로 연결(SAN 전용 스위치 필요)
   종류 : FC-SAN(광통신), IP-SAN(IP 통신)

IT 인프라(HW) - 스토리지(데이터 저장 방식)
- 블록(Block) 스토리지
   데이터를 일정한 크기의 블록으로 나누어 저장
   정형화된 데이터를 빠르게 처리하는 용도
   SAN 또는 가상머신의 디스크로 사용
- 파일(File) 스토리지
   파일과 폴더의 계층구조로 이루어진 방식
   가장 일반적으로 익숙한 방식(윈도우 탐색기)
   데이터가 많아지면 파일과 폴더를 찾는 리소스 소모 → 성능저하
- 오브젝트(Object) 스토리지
   오브젝트(비디오, 오디오, 텍스트 등)라는 개별 데이터 단위로 저장
   평면 구조로써 접근이 쉽고 확장성이 높음

IT 인프라(HW) - 운영체제
- 컴퓨터 하드웨어와 사용자 및 소프트웨어를 연결해주는 스프트웨어
   컴퓨터 시스템을 편리하게 사용할 수 있는 환경을 제공
   최대 성능을 내며 컴퓨팅 리소스를 효율적으로 관리

- 응용 프로그램 : 웹 브라우저, 오피스, 한글, 웹 서버 등
- 유틸리티 : 컴퓨터를 분석, 구성, 최적화, 유지관리 하는 시스템 소프트웨어
- 커널 : 운영체제의 핵심
- 시스템 호출 : 프로세스가 커널에 처리를 요청하는 방법
   프로세스 : 실행 중인 프로그램
- 드라이버 : 하드웨어 장치를 운영체제와 연결하는 소프트웨어
- 종류 : 유닉스, 리눅스, 윈도우

자료구조 실습 14주차

wlsn — Thu, 5 Dec 2024 16:33:19 +0900

내부 정렬
정렬할 자료를 메인메모리에 올려 정렬하는 방식
외부 정렬 - 보조기억장치에 저장함

외부 정렬 방식
병합방식 - (2-way 병합, n-way 병합)

선택 정렬
전체 원소들 중에서 기준위치에 맞는 원소를 선택하고 자리를 교환하는 방식(작은 순서대로 그 자리에 있는 원소와 교환한다고 생각해도 됨)
평균 시간복잡도 : O(n²)
{ 69 10 30 2 16 8 31 22 }
69 10 30 2 16 8 31 22 : 69, 2 교환

2 10 30 69 16 8 31 22 : 10, 8 교환

2 8 30 69 16 10 31 22 : 30, 10 교환

2 8 10 69 16 30 31 22 : 69, 16 교환

2 8 10 16 69 30 31 22 : 69, 22 교환

2 8 10 16 22 30 31 69 : 최종

버블 정렬
인접한 두 개의 원소를 비교하여 자리를 교환하는 방식
평균 시간복잡도 : O(n²)

퀵 정렬
정렬할 전체 원소에 대해서 정렬을 수행하지 않고, 기준 값을 중심으로 왼쪽 부분 집합과 오른쪽 부분 집합으로 분할하여 정렬하는 방법

왼쪽 중앙값 먼저

45 15 50 / 69 10 20 / 30 71 2 / 16 8 31
x >= 20                                x < 20

45, 8 교환

8 15 50 / 69 10 20 / 30 71 2 / 16 45 31
x >= 20                                x < 20
50, 16 교환

8 15 16 / 69 10 20 / 30 71 2 / 50 45 31
x >= 20                                x < 20

69, 2 교환 , 20 확정

오른쪽 중앙값 먼저
8 15 16 / 2 10 20 / 30 71 69 / 50 45 31
x >= 16                                x < 16

16, 10 교환 , 16 확정

8 15 10 / 2 16 20 / 30 71 69 / 50 45 31
x >= 16                                x < 16

15, 2 교환 , 15 확정

8 2 10 / 15 16 20 / 30 71 69 / 50 45 31
x >= 16                                x < 16

2, 8 교환 , 2,8 확정

2 8 10 / 15 16 20 / 30 71 69 / 50 45 31
x >= 20                                x < 20

15 확정

2 8 10 / 15 16 20 / 30 71 69 / 50 45 31 : 최종

삽입 정렬
정렬되어있는 부분집합에 정렬할 새로운 원소의 위치를 찾아 삽입하는 방법
부분집합 S와 U로 나눠 S는 정렬된 앞부분 원소, U는 정렬되지 않은 나머지 원소들을 의미한다
평균 시간복잡도 : O(n²)

{ 69 10 30 2 16 8 31 22 }

10 69 / 30 2 16 8 31 22

10 30 69 / 2 16 8 31 22

2 10 30 69 / 16 8 31 22

2 10 16 30 69 / 8 31 22

2 8 10 16 30 69 / 31 22

2 8 10 16 30 31 69 / 22

2 8 10 16 22 30 31 69 : 최종

셀 정렬
일정한 간격으로 떨어져있는 자료들끼리 부분집합을 구성하고 각 부분집합에 있는 원소들에 대해서 삽입 정렬을 수행하는 작업을 반복하면서 전체 원소들을 정렬하는 방법
일반적인 시간복잡도 : O(n¹.²⁵)
{ 69 10 30 2 16 8 31 22 }
원소 개수가 8개이므로 h=4

16 10 30 2 69 8 31 22 : 69, 16 교환
16 8 30 2 69 10 31 22 : 10, 8 교환
16 8 30 2 69 10 31 22 : 30, 31 그대로
16 8 30 2 69 10 31 22 : 2, 22 그대로

h=2로 변경
첫번째 부분집합 { 16 30 69 31 }
두번째 부분집합 { 8 2 10 22 }

16 8 30 2 31 10 69 22 : 69, 31 교환
16 2 30 8 31 10 69 22 : 8, 2 교환

h=1로 변경

2 8 10 16 22 30 31 69 : 최종

병합 정렬
여러 개의 정렬된 자료의 집합을 병합하여 한 개의 정렬된 집합으로 만드는 방법
2-way = 2의 배수 -> 2 , 4 , 8 , 10 ...
3-way = 3의 배수 -> 3 , 6 , 9 , 12 ...
n-way = n의 배수

{ 69 10 30 2 16 8 31 22 }

69 10 30 2 / 16 8 31 22 로 두갈래로 나눔
69 10 / 30 2 / 16 8 / 31 22 로 각각 두갈래로 나눔
69 / 10 / 30 / 2 / 16 / 8 / 31 / 22 로 각각 모두 나눔
10 69 / 2 30 / 8 16 / 22 31 로 순서대로 묶음
2 10 30 69 / 8 16 22 31 로 순서대로 묶음
2 8 10 16 22 30 31 69 로 모두 순서대로 묶음

문제 { 45 15 50 69 10 20 30 71 2 16 8 31 22 1 63 5 }

45 15 50 69 10 20 30 71 2 16 8 31 22 1 63 5
45 15 50 69 10 20 / 30 71 2 16 8 31 / 22 1 63 5 n n
45 15 / 50 69 / 10 20 / 30 71 / 2 16 / 8 31 / 22 1 / 63 5
45 / 15 / 50 / 69 / 10 / 20 / 30 / 71 / 2 / 16 / 8 / 31 / 22 / 1 / 63 / 5
15 45 / 50 69 / 10 20 / 30 71 / 2 16 / 8 31 / 1 22 / 5 63
10 15 20 45 50 69 / 2 8 16 30 31 71 / 1 5 22 63

1 2 5 8 10 15 16 20 22 30 31 45 50 63 69 71 : 최종

14주차 강의 내용

wlsn — Tue, 3 Dec 2024 11:52:30 +0900

제너릭 프로그래밍을 아주 쉽게 설명해볼게요.

제너릭 프로그래밍은 "모든 타입을 위한 만능 상자"라고 생각하면 돼요.

예를 들어, 우리가 "사과"와 "바나나"를 담는 상자를 만든다고 해볼게요. 일반 상자는 사과만 담을 수 있지만, 만능 상자는 사과도 담고 바나나도 담을 수 있어요.

즉, 제너릭 프로그래밍은 특정한 데이터 타입에 국한되지 않고, 다양한 타입의 데이터를 담을 수 있는 방법이에요. 이렇게 하면 코드를 더 간단하고 재사용하기 쉽게 만들어 줍니다.

그래서 제너릭 프로그래밍을 사용하면 다양한 데이터에 대해 같은 로직을 쓸 수 있어서 편리해요!

뤼튼에게 generic programming을 물었을 때의 답

generic programming은 자료형이 실행될 때 결정된다.

#include <iostream>
using std::cout;
using std::endl;

int Max(int i, int j)
{
   return i>j ?i:j;
}
double Max(double i, double j)
{ 
   return i>j ?i:j;
}
char Max(char i, char j)
{
   return i>j ?i:j;
}
int main()
{
  cout<< "Max값은=" << Max(1,2)<<endl;
  cout<< "Max값은=" << Max(7.5,3.6)<<endl;
  cout<< "Max값은=" << Max('A','B');
  return 0;
}

#include <iostream>
using std::cout;
using std::endl;
template <class T>
T Max(T i, T j)
{
	return i > j ? i : j;
}
int main()
{
	cout << "Max값은=" << Max(1, 2) << endl;
	cout << "Max값은=" << Max(7.5, 3.6) << endl;
	cout << "Max값은=" << Max('A', 'B');
	return 0;
}

첫번째 소스를 generic programming으로 바꾼 결과다 int를 T로 바꾸고 template을 쓴다.

#include <iostream> // 입력과 출력을 위한 헤더 파일 포함
using std::cout;   // std 네임스페이스의 cout 사용
using std::endl;   // std 네임스페이스의 endl 사용

// 제너릭 함수 정의: T는 타입 매개변수
template <class T>
T Max(T i, T j) // 두 개의 같은 타입 인자를 받아서 최대값을 반환
{
    return i > j ? i : j; // i가 j보다 크면 i를, 그렇지 않으면 j를 반환
}

int main() // 프로그램의 시작점
{
    // 정수형 인자를 사용하여 Max 함수 호출
    cout << "Max값은=" << Max(1, 2) << endl; // 결과: 2

    // 실수형 인자를 사용하여 Max 함수 호출
    cout << "Max값은=" << Max(7.5, 3.6) << endl; // 결과: 7.5

    // 문자형 인자를 사용하여 Max 함수 호출
    cout << "Max값은=" << Max('A', 'B'); // 결과: B

    return 0; // 프로그램 종료
}

뤼튼에게 주석을 달아달라고 했을 때의 답이다.

첫번째는 정수형, 두번째는 실수형, 세번째는 문자형이다.

뤼튼에게 언어별로 generic programming을 알려달라고 했을 때의 답이다.

지금까지 했던 template으로 T로 바꿨었던 내용이 generic funtion이다.

#include <iostream>
using std::cout;
using std::endl;
template <typename T>
T Max(T i, T j)
{
	return i > j ? i : j;
}
int main()
{
	cout << "Max값은=" << Max(1, 2) << endl;
	cout << "Max값은=" << Max(7.5, 3.6) << endl;
	cout << "Max값은=" << Max('A', 'B');
	return 0;
}

이 소스처럼 class를 typename으로 바꿔도 내용은 제대로 나온다.

class	일반적으로 클래스 타입 매개변수를 정의할 때 사용됩니다.
typename	타입 매개변수를 좀 더 일반적으로 나타낼 때 사용됩니다. 특히, 템플릿의 중첩 타입을 참조할 때 더 자주 사용됩니다.

#include <iostream>
using std::cout;
using std::endl;

template <class T1, class T2, class T3> void fun(T1 x, T2 y, T3 z)
{     // 두 개의 매개변수 자료형이 T1과 T2로 다르다.
	cout << x << "  " << y << << " "<< z << endl;
}
int main()
{
	fun("Han", 30, 2); // T1은 문자열(const char *),T2는 정수형(int)
	fun(25, 50.5, 'a');  // T1은 정수형(int), T2는 double형 
	fun(1, 2, 1.5);
	fun('a', 3.5, 'b');
	return 0;
}

시험에서 class를 안써서 틀리는 경우가 종종 있다고 한다.

보통 결정되지 않은 자료형에서는 T1, T2, T3등 Tn으로 정의한다고 한다.

1단계 template 쓰고 T1, T2 정의하기

#include <iostream>
using std::cout;
using std::endl;

template<class T1, class T2>
class CCC1
{
private:
	int x;
	int y;
public:
	CCC1(int xx, int yy) { x = xx; y = yy; }
	void Print() { cout << x << ',' << y << endl; }
};
class CCC2
{
private:
	double x;
	double y;
public:
	CCC2(double xx, double yy) { x = xx; y = yy; }
	void Print() { cout << x << ',' << y << endl; }
};
class CCC3
{
private:
	char x;
	const char* y;
public:
	CCC3(char xx, const char* yy) { x = xx; y = yy; }
	void Print() { cout << x << ',' << y << endl; }
};

int main()
{
	CCC1 c1(10, 20); //int
	CCC2 c2(3.5, 5.5); //double
	CCC3 c3('I', "Love You!"); //char

	c1.Print();
	c2.Print();
	c3.Print();
	return 0;
}

2단계 template class 완성

#include <iostream>
using std::cout;
using std::endl;

template<class T1, class T2>
class CCC
{
private:
	T1 x;
	T2 y;
public:
	CCC(T1 xx, T2 yy) { x = xx; y = yy; }
	void Print() { cout << x << ',' << y << endl; }
};
int main()
{
	CCC1 c1(10, 20); //int
	CCC2 c2(3.5, 5.5); //double
	CCC3 c3('I', "Love You!"); //char

	c1.Print();
	c2.Print();
	c3.Print();
	return 0;
}

3단계 main 함수에서 에러 고치기

#include <iostream>
using std::cout;
using std::endl;

template<class T1, class T2>
class CCC
{
private:
	T1 x;
	T2 y;
public:
	CCC(T1 xx, T2 yy) { x = xx; y = yy; }
	void Print() { cout << x << ',' << y << endl; }
};
int main()
{
	CCC<int, int> c1(10, 20); //int
	CCC<double, double> c2(3.5, 5.5); //double
	CCC<char, const char *> c3('I', "Love You!"); //char

	c1.Print();
	c2.Print();
	c3.Print();
	return 0;
}

템플릿을 만들고 결정되지 않은 자료형은 객체 앞에 꺽쇠를 넣어 지정해줘야 한다.

#include <iostream> // 입력과 출력을 위한 헤더 파일 포함
using std::cout;   // std 네임스페이스의 cout 사용
using std::endl;   // std 네임스페이스의 endl 사용

// 두 개의 타입 매개변수를 받는 템플릿 클래스 CCC 정의
template<class T1, class T2>
class CCC {
private:
    T1 x; // 타입 T1의 변수 x
    T2 y; // 타입 T2의 변수 y
public:
    // 생성자: 두 개의 매개변수를 받아서 x와 y에 초기화
    CCC(T1 xx, T2 yy) { 
        x = xx; 
        y = yy; 
    }
    
    // Print 메서드: x와 y의 값을 출력
    void Print() { 
        cout << x << ',' << y << endl; 
    }
};

int main() {
    // int 타입의 x와 y를 가지는 CCC 객체 c1 생성
    CCC<int, int> c1(10, 20); // c1은 (10, 20)으로 초기화
    // double 타입의 x와 y를 가지는 CCC 객체 c2 생성
    CCC<double, double> c2(3.5, 5.5); // c2는 (3.5, 5.5)으로 초기화
    // char와 const char * 타입의 x와 y를 가지는 CCC 객체 c3 생성
    CCC<char, const char *> c3('I', "Love You!"); // c3는 ('I', "Love You!")으로 초기화

    // 각 객체의 Print 메서드 호출
    c1.Print(); // 출력: 10, 20
    c2.Print(); // 출력: 3.5, 5.5
    c3.Print(); // 출력: I, Love You!

    return 0; // 프로그램 종료
}

위 코드는 뤼튼에게 주석을 달아달라고 했을 때의 모습이다.

함수타입을 만들 때는 typename보단 class 를 더 선호하고 template을 만들 때는 class를 더 선호한다.

vector 컨테이너

#include <iostream>
#include <vector>
using namespace std;
int main()
{
    vector <char> x;  //int x[10]와 차이
    // 여러 개 int형을 가지고 노는 배열 공간을 만들고 싶어요 
    x.push_back('a');
    x.push_back('b');
    x.push_back('c');
    for (int i = 0; i < x.size(); i++)
        cout << x[i] << endl;
    return 0;
}

길이가 자동으로 늘어나는 배열 int, double, char 등 자료형이 올 수 있음

예시 함수

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec; // 빈 벡터 생성

    vec.push_back(10);    // 10 추가
    vec.push_back(20);    // 20 추가
    vec.push_back(30);    // 30 추가

    std::cout << "Size: " << vec.size() << std::endl; // 크기 출력
    std::cout << "Front: " << vec.front() << std::endl; // 첫 번째 요소 출력
    std::cout << "Back: " << vec.back() << std::endl; // 마지막 요소 출력

    vec.pop_back();       // 마지막 요소 제거

    std::cout << "Size after pop: " << vec.size() << std::endl; // 크기 출력

    // 모든 요소 출력
    for (size_t i = 0; i < vec.size(); ++i) {
        std::cout << vec[i] << " "; // 인덱스를 사용한 접근
    }
    std::cout << std::endl;

    return 0;
}

이 예시 코드에서는 std::vector를 생성하고, 요소를 추가 및 제거하며, 다양한 멤버 함수를 사용하는 방법을 보여줍니다. std::vector는 매우 유용한 동적 배열 구조로, 다양한 상황에서 자주 사용됩니다.

언어별로 예외처리(Exception handling)에 관한 표

실행할 때 발생할 수 있는 오류를 잡아주는 것을 예외처리라고 한다.

try로 묶고 throw로 던지고 catch로 받아서 처리한다.

언어별로 조금 다르지만 try는 대부분 비슷하다고 볼 수 있다.

예외처리 1단계

실행할 때 예외가 발생 할 수 있는 줄을 묶는다.

#include <iostream>
using std::cout;
using std::cin;
using std::endl;
void Div(double ja, double mo)
{
	try {
		cout << "결과:" << ja / mo << endl;
	}
}
int main()
{
	double x, y;

	cout << "분자를 입력하세요=";
	cin >> x;
	cout << "분모를 입력하세요=";
	cin >> y;
	Div(x, y);
	return 0;
}

예외처리 2단계

예욋값을 던짐(throw와 if를 추가)

#include <iostream>
using std::cout;
using std::cin;
using std::endl;
void Div(double ja, double mo)
{
	try {
		if(mo == 0) throw mo;
		cout << "결과:" << ja / mo << endl;
	}
}
int main()
{
	double x, y;

	cout << "분자를 입력하세요=";
	cin >> x;
	cout << "분모를 입력하세요=";
	cin >> y;
	Div(x, y);
	return 0;
}

예외처리 3단계(완성)

오류가 발생되면 catch로 이동하여 처리됨

#include <iostream>
using std::cout;
using std::cin;
using std::endl;
void Div(double ja, double mo)
{
	try {
		if(mo == 0) throw mo;
		cout << "결과:" << ja / mo << endl;
	}
	catch (double) {
		cout << "오류 : 0으로 나눌 수 없음";
	}
}
int main()
{
	double x, y;

	cout << "분자를 입력하세요=";
	cin >> x;
	cout << "분모를 입력하세요=";
	cin >> y;
	Div(x, y);
	return 0;
}

catch는 예욋값의 자료형을 써준다.

catch는 여러 개를 만들어 다양한 자료형을 넣어 그때마다 다르게 사용 할 수 있다.

참조자(reference) 매우중요

#include <iostream>
using std::cout;
using std::endl;
int main(void)
{
    int x = 10;
    int &rx = x;
    cout << x << " " << rx << endl;
    rx = rx + 10;
    cout << x << " " << rx << endl; //참조자(rx)에 변화를 주면 그 타켓(x)도 변함
    x = x + 10;
    cout << x << " " << rx << endl; //타켓(x)에 변화를 주면 그 참조자(rx)도 변함
    return 0;
}

참조자를 붙인다면 rx=x가 됨으로 둘다 동시에 변하게 되어 10 10 20 20 30 30이 나오게 된다.

콘솔 파일 입출력은 시험범위는 19p, 24p, 27p,

width는 출력폭을 지정

precision은 소수점 자릿수 지정

fill은 공백구간에 ch 문자를 채움

fixed는 소수점 이하의 자릿수를 다룸

#include <iostream>
using namespace std;
int main() {
    cout << "디폴트\n";
    cout.fill('*');
    cout.width(10);
    cout << -50 << endl;
    cout << "[ * fill ]\n";
    cout.fill('#');
    cout.width(10);
    cout << -50 << endl;
    cout.width(10);
    cout << 100.25 << endl;
    cout.width(10);
    cout << "HanSH" << endl;
    cout.fill(' ');
    cout.precision(5);  //소수점을 제외한 전체 자리수 
    cout << 12.34567 << endl;
    cout << fixed;  //소수점 이하의 자리수만 다루게 함 
    cout.precision(1);
    cout << 12.34567 << endl;
    return 0;
}

이 소스가 더 쉬워보이지만 <iomanip>를 포함시켜줘야된다.

#include <iostream>
#include <fstream>
using namespace std;

int main()
{
    ofstream fout("a1.txt");
    fout << "abcddatw\n";
    cout << "abc\n";
}

ofstream을 써 메모장으로 출력하게 만든 소스다.

cout은 abc로 출력이 되지만 메모장에 저장되는 값은 abcddatw다.

#include <iostream>
#include <fstream>
using namespace std;

int main()
{
    int x;

    ofstream fout("a.txt");
    fout << 2345;
    fout.close();

    ifstream fin("a.txt");
    fin >> x;
    cout << x;
}

파일을 만들었으면 다른 파일을 실행하기 전에 무조건 close로 닫아야 한다.

위 파일은 ofstream으로 a라는 메모장파일을 만들어 2345라는 값을 저장한 후 출력하게 하는 코드다.

ppt 출처 : Smlie Han

14주차 예습과제

wlsn — Tue, 3 Dec 2024 01:46:26 +0900

1. 강의 주제 : 템플릿의 기본 개념

2. 강의 키워드(주요 단어) : 팀플릿, generic, reference

3. 주요 내용 요약

템플릿 (template)

- 다형성의 종류

└ 템플릿(인자 다형성) : C++에서 다형성을 실현하는 또 다른 방법

└ 코어션 : 수식, 변수 등의 불일치가 발생했을 때 형변환을 시켜주는 기능

템플릿 구현 형식(generic function)

- 템플릿 : 포괄적 함수

└ 템플릿은 인자(매개변수)를 통한 다형성을 제공한다.

└ 함수 중첩은 기능이 같은 함수들을 같은 이름으로 사용할 수 있도록 한다.

└ 함수의 매개변수의 형과 수로 구분이 되고, 코드 자체도 다르게 구성될 수 있다.

└ 코드는 전혀 바뀌지 않고 형만 다른 함수를 필요로 한다면 템플릿을 사용하는 것이 좋다.

└ 이는 값 뿐만이 아니라 형을 인자로 받는 함수로서 인자로 받은 형에 대하여 함수를 생성시키는 포괄적 함수(generic function)이다.

참조자(reference)

- C++에서만 사용 가능

- 참조자를 사용하려면 파일명이 .cpp 이여야함

- 변수의 별명

└ (int &rx=x;)

└ rx는 x를 참조하도록 초기화된 정수형 참조자

└ 참조자(rx)에 변화를 주면 그 타겟(x)도 변함

변수를 선언할 때 아무것도 없으면 ①일반변수, ②*가 있으면 포인터변수, ③&가 있으면 레퍼런스 변수다.

C/C++에서 가장 눈에 거슬리는 *과 &

문\기호	*		&
선언문(구두점)	예시	int *px = &x;	예시	int &rx=x;
선언문(구두점)	의미	px는 변수를 x의 주소를 저장하는 포인터 변수	의미	rx는 x의 참조자(별명)
실행문(연산자)	예시	px = 10; y= px;	예시	px=&x;
실행문(연산자)	의미	px가 가르키는 주소의 내용	의미	x변수의 주소

파일 입출력 개념 및 기본 형식

- 파일 입출력 동적을 수행하기 위해 ifstream, ofstream, fstream 클래스가 있으며 이들 클래스는 fstream 헤더파일에 정의되어 있다.

- ifstream : 파일로부터 입력(파일 읽기) 동작을 수행하기 위한 스트림 클래스

- ofstream : 파일로 출력(파일 쓰기)하기위한 스트림 선언하는 클래스

- fstream : 입출력 동작 모두를 위한 스트림 선언할 때 사용됨

- 파일스트림의 객체는 사용자가 직접 프로그램 상에서 선언해야하고, 파일을 개방(open)하고 종결(close)하는 동작이 필요함

파일의 개방 및 종결 형식

파일 개방하는 2가지 방식( 1줄, 2줄 )

- 파일클래스 스트림객체명(파일명, 개방모드);

└ 파일클래스 : ifstream, ofstream, fstream

└ 개방모드 : ios::in(입력), ios::out(출력)

- 파일클래스 스트림객체명;

스트림객체명.open(파일명, 개방모드);

파일 종결하는 방식

- 스트림객체명.close();

4. 감상 평

변수를 선언할 때 일반변수, 포인터변수, 레퍼런스변수를 정확하게 알게 되었다.

5. 강의 이해도

70%

13주차 강의 내용

wlsn — Tue, 26 Nov 2024 11:51:28 +0900

부모는 protected, 자식은 public으로 하는 것이 보편적이다.

C++에서 가상함수의 구현을 overriding이라고 한다.

overriding에서 virtual을 써야지 public에 있는게 써진다.

변수,함수에 대한 메모리 할당, 함수호출이 발생 했을때 명령어들이 결정되는 시점을 바인딩이라고 부른다.

static을 안줘서 1010 1010 1010이 찍힌 모습.

static을 주자 없던 y값이 생긴 모습

static은 마치 시작프로그램과 비슷하다고 생각하면 된다. 컴파일을 시작할 때 미리 자리를 잡고있기 때문이다.

실행할때는 16줄을 건너뛰고 실행이 된다. 왜냐하면 이미 컴파일을 시작했을 때 정해졌기 때문이다.

1010을 찍고 난 후 지역변수를 벗어나 x는 쓰레기값으로 바뀌지만 static으로 고정된 y는 11로 y++이 된 모습이다.

결과적으로 sub()를 3개를 써서 1010 1011 1012가 찍히게 된다.

멤버변수 앞에 static을 쓴다면 정적멤버변수로 바뀐다.

*객체들이 정보를 공유할 목적으로 사용하는 변수*

멤버변수는 각 개체마다 따로 생성되고

멤버함수는 모든 객체가 공유함.

사람으로 치면 나이,얼굴, 다리, 팔 같은 명사적인 사항이 멤버변수고 숨쉬기, 뛰기 등 동사적이고 공통적인 사항이 멤버함수라고 할 수 있다.

객체들을 공유하고 싶을 때 static을 붙여 공유하게 할 수 있다.

#include <iostream>
using std::cout;
class Point {
	int x;
	int y;
	static int count; //선언
public:
	Point() { cout << ++count; }
	~Point() { cout << --count; }
};
int Point::count = 0; //정의
int main()
{
	Point p1, p2, p3;
	return 0;
}

이 소스를 Python Tutor에 넣었을 때

123210이 찍히게 된다.

int Point::count = 0;을 주석처리한다면 오류가 뜨게된다.

6번째 줄에 static이 이미 선언되어 있기 때문에 class밖에 정의를 해줘야 오류가 생기지 않는다.

virtual부분은 overriding, public에 기능이 달라지는 것은 overloading이다.

순수가상함수를 갖는 클래스를 추상클래스라고 한다.

추상클래스는 객체를 만들 수 없어 주석처리로 바꾸고 다시 실행을 한다면

이와 같은 결과가 나온다.

순수가상함수는 'virtual', 뒤에 =0 을 붙이면 만들 수 있고 추상클래스를 정의하는데 사용함하지만 인스턴스는 생성불가능(불안정하기 때문에)

virtual을 추가하고 override는 생략이 가능하지만 써주는것이 좋다.

왼쪽의 결과는 Dot클래스 Dot이지만 오른쪽은 Dot클래스 line으로 바뀐다.

13주차 예습과제

wlsn — Tue, 26 Nov 2024 01:33:29 +0900

강의 주제 : 바인딩과 오버로딩vs오버라이딩

강의 키워드(주요 단어) : 바인딩, 오버로딩, 오버라이딩, 정적(static)멤버변수, 가상함수, 순수가상함수

주요 내용 요약

가상함수(overriding)의 필요성, (최우선의 라는 뜻도 가지고 있다.)

클래스를 상속 받아서 쓰는데, 상속 받은 클래스의 함수 중 고치고 싶은 함수가 있을 때

기존 클래스의 모든 내용을 모두 현재 프로그램에 사용할 수 있는데, 특정 함수가 마음에 들지 않음

기존의 클래스를 고치느니 상속을 받고, 가상함수를 이용하여 기존의 함수를 고쳐서 사용

상속 받은 함수(부모)를 실행하지 않고 자신(자식)의 함수를 실행

가상함수의 구현을 중복(overriding)이라고 함

바인딩(binding)

- 변수와 함수에 대한 메모리 할당이나 함수 호출이 발생했을 때 실제로 처리해야하는 명령어들이 결정되는 시점

- 정적(static) 바인딩, early

└ 컴파일 시 변수의 위치와 함수가 실행할 명령이 결정되는 경우

└ static 변수, overloading

- 동적(dynamic) 바인딩, late

└ 실제 실행할 때(run time) 결정되는 경우

└ 지역변수, overriding

C++과 C에서 auto는 원래 같은 문법이였지만 C++11에서 auto는 기억클래스 지정자가 아닌 동적으로 타입을 정하게 바뀌었다.(stl 사용시 코드가 짧고 가독성이 좋아짐)

정적(static) 멤버변수

- 모든 객체가 공유하는 멤버변수

- 한 클래스로부터 객체가 여러개 만들어지더라도 멤버변수당 하나씩 생성됨

- 여러 객체들에서 공유해야하는 정보는 멤버변수로 선언함

cast연산자

- static_cast

- dynamic_cast : 안전한 downcasting (왠만해서는 잘 쓰이지 않음)

└ 부모 클래스의 포인터에서 자식 클래스의 포인터로 다운 캐스팅

- const_cast

- reinterpret_cast

- C/C++ cast 연산자

└ (type)(expression)

└ (double)x;

- C++ cast 연산자

└ 연산자<type>(expression)

└ static_cast<double>(x);

기본 클래스(base)

↑ : upcasting(문제x)

↓ : down casting

파생 클래스(Derived)

가상함수(virtual function)

- 오버라이딩을 구현하는 방법

- 동적(실행시) 바인딩, late binding

- 가상함수를 정의하기 위해서는 기본 클래스의 멤버함수 앞에 'virtual'이라는 키워드를 씀

- 가상함수는 하나의 이름(인터페이스)으로 여러 개의 수단과 방법을 제공하는 객체지향 프로그래밍의 다형성을 구현하는 한 방법

- 기본 클래스에서 상속 받았는데 파생 클래스에서 멤버함수를 재정의하는 이유는 어떠한 경우라도 기본클래스의 멤버함수를 버리고 파생 클래스의 멤버함수를 사용하려는 것

- 기존 클래스의 모든 내용을 모두 현재 프로그램에 사용할 수 있는데 특정 함수가 걸맞지 않을 경우, 기존의 클래스를 고치느니 상속을 받고 가상함수를 이용하여 마음에 들지 않는 함수만 고쳐서 사용함

순수가상함수(pure virtual function)

- 파생클래스에서 반드시 재정의를 해야함

- 순수가상함수를 갖는 클래스는 "추상클래스"라고 부름

- 추상클래스는 객체생성이 안된다.

감상 평

새로운 가상함수, overloading vs overriding의 개념을 배울 수 있어 재밌었다.

강의 이해도

75%

12주차 강의내용

wlsn — Tue, 19 Nov 2024 13:40:47 +0900

aa.을 하면 class A에 있는 public부분에 b1~b4까지 나타낼 수 있다.

B는 아무것도 없기때문에 나타나지 않는다.

하지만 상속을 한다면 부모의 public을 물려받을 수 있다.

C++, JAVA, python의 상속 예제다.

C++

#include <iostream>
using std::cout;

class Animal { // 기본 클래스
public:
    void speak() { cout << "Animal speaks\n"; } // 기본 클래스의 메서드
};

class Dog : public Animal { // 파생 클래스
public:
    void speak() { cout << "Dog barks\n"; } // 오버라이드된 메서드
};

int main() {
    Animal a;
    a.speak(); // 출력: Animal speaks

    Dog d;
    d.speak(); // 출력: Dog barks

    return 0;
}

JAVA

class Animal { // 기본 클래스
    void speak() {
        System.out.println("Animal speaks"); // 기본 클래스의 메서드
    }
}

class Dog extends Animal { // 파생 클래스
    void speak() {
        System.out.println("Dog barks"); // 오버라이드된 메서드
    }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.speak(); // 출력: Animal speaks

        Dog d = new Dog();
        d.speak(); // 출력: Dog barks
    }
}

python

class Animal:  # 기본 클래스
    def speak(self):
        print("Animal speaks")  # 기본 클래스의 메서드

class Dog(Animal):  # 파생 클래스
    def speak(self):
        print("Dog barks")  # 오버라이드된 메서드

if __name__ == "__main__":
    a = Animal()
    a.speak()  # 출력: Animal speaks

    d = Dog()
    d.speak()  # 출력: Dog barks

상속관계는 다른말로 is a 관계라고도 볼 수 있다.

부모클래스에서 public으로 상속받은 자식클래스라고 읽을 수 있다.

상속의 접근 제어는 파생 클래스에서 기본 클래스의 멤버에 대한 접근 권한을 정의합니다.
public 상속을 통해 protected와 public 멤버는 파생 클래스에서 그대로 접근할 수 있게 됩니다.

대체로 public 상속은 C++에서 가장 많이 사용되는 상속 형태이며, 많은 개발자들이 기본 클래스의 기능을 확장하고 재사용하기 위해 이를 선택합니다. 그러나 특정 상황에서는 protected나 private 상속이 더 적합할 수 있습니다. 따라서, 실제 비율은 프로젝트나 개별 개발자의 스타일에 따라 다를 수 있습니다.

상속이되면 public으로 한다고해도 private은 절때로 넘어가지않고 protected와 public은 넘길 수 있다.

#include <iostream>
using std::cout;
using std::endl;
class A // 기본 클래스
{
	int x;
public:
	void setX(int i) { x = i; }
	void showX() { cout << x << endl; }
};
class B :public A //파생 클래스
{
	int y;
public:
	void setY(int i) { y = i; }
	void showY() { cout << y << endl; }
};
int main()
{
	B bb; // 파생클래스의 객체
	bb.setX(1); // 오류 ① bb.setX(1);
	bb.setY(1); // 오류 ② bb.setY(2);
	bb.showX(); // 기본클래스의 멤버접근
	bb.showY(); // 파생클래스의 멤버접근
	return 0;
}

private은 상속도 안되며 각 class에서만 사용할 수 있다.

부모의 public을 통해서 접근을 할 수 있다.

private 상속은 protected나 public이 protected나 public으로 갔던 것을 모두 private으로 가게하는 상속이다.

#include <iostream>
using std::cout;
using std::endl;
class A
{
	int x; //int x=10; //가능?
public:
	void setX(int i) { x = i; }
	void showX() { cout << x << endl; }
};
class B :private A //비공개적으로 상속
{
	int y;
public:
	void setY(int i) { y = i; }
	void showY() { cout << y << endl; }
};
int main()
{
	A aa;
	B bb;
	aa.setX(1);
	aa.showX();
//	bb.setX(1); // 오류
	bb.setY(2); // 파생클래스의 멤버접근
//	bb.showX(); // 오류
	bb.showY(); // 파생클래스의 멤버접근
	return 0;
}

setX에 경우 private으로 가기 때문에 bb.setX(1);을 불러온다면 private으로 외부에서 접근하는 것이기 때문에 오류가 뜰 수 밖에 없다.

왼쪽 소스에서 빨간부분 = 1을 뺀다면 쓰레기 값이 출력된다.

#include <iostream>
using std::cout;
using std::endl;
class A
{
	int x = 1;
public:
	A() { x = 2; }
	A() : x(2) {}
	void setX(int i) { x = i; }
	int getX() { return x; }
};
int main()
{
	A a1; //디폴트 생성자는 사라짐
	cout << a1.getX() << endl;
	return 0;
}

public부분에 A()는 두 생성자는 같다고 볼 수 있다. 시험에 꼭 출제된다고 함.

protected는 잘 사용하지 않지만 protected와 public이 둘다 protected로 간다. 하지만 거의 쓰지 않는 상속법.

private과 protected의 공통점은 외부에서 접근이 불가능하다. 고로 public으로 접근해야 함.

a,b는 "자식"이외 외부에서 접근 불가, a,b가 자식에게 상속안됨, a,b는 A클래스 내에서 접근 가능

protected 접근제어의 장점

1. 상속 관계에서의 접근 허용
protected 멤버는 기본 클래스의 파생 클래스에서 접근할 수 있습니다. 이를 통해 기본 클래스의 기능을 확장하면서도 멤버 변수를 보호할 수 있습니다.

2. 캡슐화 유지
protected는 외부 클래스나 함수에서는 접근할 수 없지만, 상속받은 클래스에서는 접근할 수 있기 때문에, 클래스를 사용하는 외부 코드와 내부 구현을 분리하여 캡슐화를 유지할 수 있습니다.

3. 유연성 제공
파생 클래스에서 기본 클래스의 protected 멤버를 사용할 수 있어, 기본 클래스의 기능을 재사용하고 확장하는 데 유리합니다. 이는 코드의 유연성을 높입니다.

4. 다형성 지원
protected 멤버는 다형성을 구현할 때 유용합니다. 파생 클래스에서 기본 클래스의 protected 멤버를 오버라이드하거나 사용하여, 더 구체적인 동작을 정의할 수 있습니다.

5. 정보 은닉
외부에서 직접 접근할 수 없기 때문에, 데이터의 안전성을 유지하면서도 상속받은 클래스에서 필요한 기능을 사용할 수 있습니다. 이는 불필요한 데이터 노출을 방지합니다.

#include <iostream>
using std::cout;
using std::endl;
class A
{
protected: //private이라면?
	int a, b;
public:
	void setAB(int i, int j) { a = i; b = j; }
};
class B :public A
{
	int c; // private
public:
	void setC(int n) { c = n; }
	void showABC() { cout << a << b << c << endl; }
	//기본 클래스의 protected 멤버들은
	//파생 클래스의 멤버에 의해 접근될 수 있다.
};
int main()
{
	A aa;
	B bb;
//	aa.a; //외부에서는 접근불가
//	bb.b; //외부에서는 접근불가
	bb.setAB(1, 2);
	bb.setC(3);
	bb.showABC();
	return 0;
}

main부분에 aa.a와 bb.b는 외부에서는 접근이 안되기 때문에 오류를 이르킴.

#include <iostream>
using std::cout;
using std::endl;

class A {
    int a;
public:
    A(int i) {
        cout << "A의 생성자\n";
        a = i;
    }
    ~A() { cout << "A의 소멸자\n"; }
    void showA() { cout << a << '\n'; }
};

class B : public A {
    int b;
public:
    // A의 생성자를 호출하기 위해 초기화 목록 사용
    B(int i, int j) : A(i) { // i는 기본클래스 생성자의 매개변수로 전달
        cout << "B의 생성자\n";
        b = j;
    }
    ~B() { cout << "B의 소멸자\n"; }
    void showB() { cout << b << endl; }
};

int main() {
    B bb(10, 20); // B 객체 생성
    bb.showA();  // A의 멤버 출력
    bb.showB();  // B의 멤버 출력
    return 0;
}

A의 생성자부분을 먼저 가져와야하기 때문에 A(i)부분을 뺀다면 오류가 난다.

#include <iostream>
using std::cout;
using std::endl;
class A1 // 아버지
{
	int a;
public:
	A1(int i) { a = i; }
	int getA() { return a; }
};
class A2 // 어머니
{
	int b;
public:
	A2(int i) { b = i; }
	int getB() { return b; }
};
class B :public A1, public A2
{
	// 기본 클래스 A1과 A2로부터
	// 상속 받은 파생 클래스
	int c;
public:
	B(int i, int j, int k) :A1(i), A2(j) { c = k; }
	// i는 기본클래스 A1의 생성자로,
	// j는 기본클래스 A2의 생성자로
	// 각각 매개변수 전달
	void show() {
		cout << getA() << ' ' << getB() << ' ' << c << endl;
	}
};
int main()
{
	B bb(1, 2, 3);
	bb.show();
	return 0;
}

#include <iostream>
using std::cout;
class A1 // 기본 클래스 1
{
	int a;
public:
	A1() { cout << "A1의 생성자.\n"; }
	~A1() { cout << "A1의 소멸자.\n"; }
};
class A2 // 기본 클래스 2
{
	int b;
public:
	A2() { cout << "A2의 생성자.\n"; }
	~A2() { cout << "A2의 소멸자.\n"; }
};
class B : public A2, public A1
	// 기본 클래스 1과 2로부터
	// 상속 받은 파생 클래스
{
	int c;
public:
	B() { cout << "B의 생성자.\n"; }
	~B() { cout << "B의 소멸자.\n"; }
};
int main()
{
	B bb;
	return 0;
}

class B : public A1, public A2를 서로 바꿔서 쓴다면 부모가 바뀔 수 있다.

학생과 교수 class

1단계

#include <iostream>
using std::cout;
using std::endl;

int main()
{

	return 0;
}

2단계

#include <iostream>
using std::cout;
using std::endl;
//사람클래스(Man, 멤버변수:이름, 나이)를 만드시오.
//멤버변수를 초기화하는 생성자를 구현하시오.
//기타 함수를 구현하시오.
//사람클래스로부터 상속받은 학생클래스(Student)를 만드시오.
//(멤버변수:반, 학번), 생성자, 기타함수
//사람클래스로부터 상속받은 교수(Teacher)클래스를 만드시오.
//(멤버변수:전공, 담당과목), 생성자, 기타함수
//main함수에서 학생객체와, 교수객체를 만들어 테스트해보시오.

int main()
{
//	Student kks("김컴소", 20, "C반", "202012000");
//	Teacher hsh("한미소", 40, "전산", "C++프로그래밍");
	return 0;
}

3단계

#include <iostream>
using std::cout;
using std::endl;
//사람클래스(Man, 멤버변수:이름, 나이)를 만드시오.
//멤버변수를 초기화하는 생성자를 구현하시오.
//기타 함수를 구현하시오.
class Man {
protected:
	std::string name;
	int age;//멤버변수 완성
};
//사람클래스로부터 상속받은 학생클래스(Student)를 만드시오.
//(멤버변수:반, 학번), 생성자, 기타함수
//사람클래스로부터 상속받은 교수(Teacher)클래스를 만드시오.
//(멤버변수:전공, 담당과목), 생성자, 기타함수
//main함수에서 학생객체와, 교수객체를 만들어 테스트해보시오.

int main()
{
//	Student kks("김컴소", 20, "C반", "202012000");
//	Teacher hsh("한미소", 40, "전산", "C++프로그래밍");
	return 0;
}

4단계

#include <iostream>
using std::cout;
using std::endl;
using std::string;
//사람클래스(Man, 멤버변수:이름, 나이)를 만드시오.
//멤버변수를 초기화하는 생성자를 구현하시오.
//기타 함수를 구현하시오.
class Man {
protected:
	string name;
	int age;//멤버변수 완성
public:
	Man(string n, int a) { name = n, age = a; } //생성자는 class 이름과 같다.
};
//사람클래스로부터 상속받은 학생클래스(Student)를 만드시오.
//(멤버변수:반, 학번), 생성자, 기타함수
//사람클래스로부터 상속받은 교수(Teacher)클래스를 만드시오.
//(멤버변수:전공, 담당과목), 생성자, 기타함수
//main함수에서 학생객체와, 교수객체를 만들어 테스트해보시오.

int main()
{
//	Student kks("김컴소", 20, "C반", "202012000");
//	Teacher hsh("한미소", 40, "전산", "C++프로그래밍");
	return 0;
}

생성자 만들기

5단계

#include <iostream>
using std::cout;
using std::endl;
using std::string;
//사람클래스(Man, 멤버변수:이름, 나이)를 만드시오.
//멤버변수를 초기화하는 생성자를 구현하시오.
//기타 함수를 구현하시오.
class Man {
protected:
	string name;
	int age;//멤버변수 완성
public:
	Man(string n, int a) { name = n, age = a; } //생성자는 class 이름과 같다.
	void m_show() {
		cout << "이름 : " << name << endl;
		cout << "나이 : " << age << endl;
	}
};
//사람클래스로부터 상속받은 학생클래스(Student)를 만드시오.
//(멤버변수:반, 학번), 생성자, 기타함수
//사람클래스로부터 상속받은 교수(Teacher)클래스를 만드시오.
//(멤버변수:전공, 담당과목), 생성자, 기타함수
//main함수에서 학생객체와, 교수객체를 만들어 테스트해보시오.

int main()
{
//	Student kks("김컴소", 20, "C반", "202012000");
//	Teacher hsh("한미소", 40, "전산", "C++프로그래밍");
	return 0;
}

m_show를 만들고 부모 class 완성

6단계

#include <iostream>
using std::cout;
using std::endl;
using std::string;
//사람클래스(Man, 멤버변수:이름, 나이)를 만드시오.
//멤버변수를 초기화하는 생성자를 구현하시오.
//기타 함수를 구현하시오.
class Man {
protected:
	string name;
	int age;//멤버변수 완성
public:
	Man(string n, int a) { name = n, age = a; } //생성자는 class 이름과 같다.
	void m_show() {
		cout << "이름 : " << name << endl;
		cout << "나이 : " << age << endl;
	}
};
class Student : public Man { // public Man으로 상속받기
private:
	string ban;
	string hak;
public:
	Student(string n, int a, string b, string h) : Man(n,a) { ban = b, hak = h; }
};
//사람클래스로부터 상속받은 학생클래스(Student)를 만드시오.
//(멤버변수:반, 학번), 생성자, 기타함수
//사람클래스로부터 상속받은 교수(Teacher)클래스를 만드시오.
//(멤버변수:전공, 담당과목), 생성자, 기타함수
//main함수에서 학생객체와, 교수객체를 만들어 테스트해보시오.

int main()
{
//	Student kks("김컴소", 20, "C반", "202012000");
//	Teacher hsh("한미소", 40, "전산", "C++프로그래밍");
	return 0;
}

7단계

#include <iostream>
using std::cout;
using std::endl;
using std::string;
//사람클래스(Man, 멤버변수:이름, 나이)를 만드시오.
//멤버변수를 초기화하는 생성자를 구현하시오.
//기타 함수를 구현하시오.
class Man {
protected:
	string name;
	int age;//멤버변수 완성
public:
	Man(string n, int a) { name = n, age = a; } //생성자는 class 이름과 같다.
	void m_show() {
		cout << "이름 : " << name << endl;
		cout << "나이 : " << age << endl;
	}
};
class Student : public Man { // public Man으로 상속받기
private:
	string ban;
	string hak;
public:
	Student(string n, int a, string b, string h) : Man(n,a) { ban = b, hak = h; }
	void s_show() {
		m_show();
		cout << "반 : " << ban << endl;
		cout << "학번 : " << hak << endl;
	}
};
//사람클래스로부터 상속받은 학생클래스(Student)를 만드시오.
//(멤버변수:반, 학번), 생성자, 기타함수
//사람클래스로부터 상속받은 교수(Teacher)클래스를 만드시오.
//(멤버변수:전공, 담당과목), 생성자, 기타함수
//main함수에서 학생객체와, 교수객체를 만들어 테스트해보시오.

int main()
{
//	Student kks("김컴소", 20, "C반", "202012000");
//	Teacher hsh("한미소", 40, "전산", "C++프로그래밍");
	return 0;
}

8단계

#include <iostream>
using std::cout;
using std::endl;
using std::string;
//사람클래스(Man, 멤버변수:이름, 나이)를 만드시오.
//멤버변수를 초기화하는 생성자를 구현하시오.
//기타 함수를 구현하시오.
class Man {
protected:
	string name;
	int age;//멤버변수 완성
public:
	Man(string n, int a) { name = n, age = a; } //생성자는 class 이름과 같다.
	void m_show() {
		cout << "이름 : " << name << endl;
		cout << "나이 : " << age << endl;
	}
};
class Student : public Man { // public Man으로 상속받기
private:
	string ban;
	string hak;
public:
	Student(string n, int a, string b, string h) : Man(n,a) { ban = b, hak = h; }
	void s_show() {
		m_show();
		cout << "반 : " << ban << endl;
		cout << "학번 : " << hak << endl;
	}
};
class Teacher : public Man { // public Man으로 상속받기
private:
	string jaun;
	string dam;
public:
	Teacher(string n, int a, string j, string d) : Man(n, a) { jaun = j, dam = d; }
	void t_show() {
		m_show();
		cout << "전공 : " << jaun << endl;
		cout << "담당과목 : " << dam << endl;
	}
};
//사람클래스로부터 상속받은 학생클래스(Student)를 만드시오.
//(멤버변수:반, 학번), 생성자, 기타함수
//사람클래스로부터 상속받은 교수(Teacher)클래스를 만드시오.
//(멤버변수:전공, 담당과목), 생성자, 기타함수
//main함수에서 학생객체와, 교수객체를 만들어 테스트해보시오.

int main()
{
	Student kks("김컴소", 20, "C반", "202012000");
	Teacher hsh("한미소", 40, "전산", "C++프로그래밍");

	kks.s_show();
	hsh.t_show();
	return 0;
}

총 완성형의 모습이다.

12주차 예습과제

wlsn — Mon, 18 Nov 2024 21:36:27 +0900

강의 주제 : 상속(코드 재사용)기본 개념 실습

강의 키워드(주요 단어) : 기본클래스와 파생클래스, public, private

주요 내용 요약

상속 코드 재사용

class A에서 만든 함수를 class B에서 class B : public A로 쓴다면 class public을 가져와 쓸 수 있다.

상속성(inheritance)

C++에선 상속성을 제공하여 작업의 중복을 지양하고 프로그램의 개발기간 단축, 기존의 프로그램 재사용, 경비절감 등을 이룰 수 있다.

이미 존재하는 클래스로부터 기본적인 특성을 물려받아 그대로 사용하고 새로운 특성만을 추가로 정의함.

클래스의 계층구조

위쪽의 클래스는 일반되어 속성이 간단하며, 아래 클래스들의 공통적인 속성만을 갖는다.

아래쪽의 클래스는 위쪽 클래스의 속성을 상속받으며, 자신의 개별적인 속성을 추가하여 속성이 많아진다.

상속과정

계층적으로 상속을 받게 되면 기존의 클래스를 그대로 사용할 수 있는 장점이 있고 또한 새로운 클래스를 보다 쉽게 만들 수 있다.

부모 superclass : 기본(Base) 클래스

inherits from ↑(클래스 다이어그램) 상속과정

자식 subclass : 파생(Derived) 클래스

A is a subclass of B

B is a superclass of A

클래스의 상속 형식

class 파생클래스명 : 상속접근제어 기본 클래스명{

};

class Dog (파생클래스명) : public Animal(기본클래스명) { //예시

};

Animal 클래스로부터 public으로 상속받은 Dog 클래스

상속 접근제어 속성에 따른 파생 클래스 멤버의 속성변화

상속접근제어 속성에 따라 기본 클래스 멤버의 속성이 파생 클래스에서 어떻게 변화하는지를 나타낸다.

상속접근제어속성 private protected public

기본클래스의 속성

private 상속불가 상속불가 상속불가

protected private protected protected

public private protected public

public 상속 접근제어

public 상속 접근인 경우에는 기본 클래스의 모든 public, protected멤버들은 파생 클래스의 public, protected 멤버가 된다.

기본 클래스의 private 멤버는 private 멤버로 남고, 파생 클래스에 의해서 접근될 수 없고, 일반적으로 가장 많이 사용하는 상속 접근 제어이다.

private 상속 접근제어

private 상속 접근인 경우에는 기본 클래스의 모든 멤버가 파생 클래스의 private 멤버가 된다.

기본 클래스의 public 멤버들은 클래스의 외부 (main함수 등)에서는 접근이 불가능 하고, 오직 파생클래스의 멤버함수에 의해서만 접근할 수 있다.

다른 사람 모르게 자기 자식에게만 비밀리에 상속함

감상 평

상속제어접근이라는 키워드를 배워 낯설지만 재미가 있다.

강의 이해도

65%