C++ 정리 #예외처리 ~

 

 

1. 예외 처리가 무엇인가.

예외 (exception) : 잘못된 코드 , 부정확한 데이터 , 예외적인 상황에 의하여 발생하는 오류 (예) 0으로 나누는 것과 같은 잘못된 연산이나 배열의 인덱스가 한계를 넘을 수 도 있고 , 디스크에서는 하드웨어 에러가 발

2. 예외처리 방법

1. 예외부분을 하나하나 조건 처리함

3. 예외처리 타입

try-catch 블록

try : 예외가 발생할 수 있는 위험한 코드

catch : 예외를 처리하는 코드

throw: 예외 상황이 발생항렸음을 알릴 때 사용함

Copy

//예외처리기 매개변수 모든타입 가능함
throw persons;

catch (...) 
{
}

catch(TooSmallException e) {
//TooSmallException만 잡힌다.
}

//예외처리기 매개변수 타입일치해야됨 !!

throw persons;

catch (int e) 
{
}


catch(...) {
//TooSmallException을 제외한 나머지 예외들이 잡힌다.
}

Copy

int main()
{
int pizza_slices = 0;
int persons = -1;
int slices_per_person = 0;
try
{
		cout << "피자 조각수를 입력하시오: ";
		cin >> pizza_slices;
		cout << "사람수를 입력하시오: ";
		cin >> persons; //예외처리기 매개변수 타입일치해야됨
		if (persons == 0)
			throw persons;
		slices_per_person = pizza_slices / persons;
		cout << "한사람당 피자는 " << slices_per_person << "입니
		다." << endl;
}
catch (int e) //예외처리기 매개변수 타입일치해야됨
{
		cout << "!!사람이 " << e << " 명 입니다. " << endl;
		}

return 0;
}

Copy

//예외처리기 함수로 매개변수를 받는 
#include <iostream>
using namespace std;
int dividePizza(int pizza_slices, int persons);
int main()
{
int pizza_slices = 0;
int persons = 0;
int slices_per_person = 0;

try
{
		cout << "피자 조각수를 입력하시오: ";
		cin >> pizza_slices;
		cout << "사람수를 입력하시오: ";
		cin >> persons;
		slices_per_person = dividePizza(pizza_slices, persons);
		cout << "한사람당 피자는 " << slices_per_person << "입니
		다." << endl;
}
int dividePizza(int pizza_slices, int persons)
{
if (persons == 0)
	throw persons;
return pizza_slices / persons ;}

catch (int e)
{
	cout << "!! 사람이 " << e << " 명 입니다. " << endl;
}
return 0;
}

Copy

//다중 catch 문
try {
	cout << "피자 조각수를 입력하시오: ";
	cin >> pizza_slices;
	cout << "사람수를 입력하시오: ";
	cin >> persons;
	if (persons < 0) throw "negative"; // 예외 발생!
	if (persons == 0) throw persons; // 예외 발생!
	slices_per_person = pizza_slices / persons;
	cout << "한사람당 피자는 " << slices_per_person << "입니다." << endl;
}
catch (const char *e) {
	cout << "오류: 사람수가 " << e << "입니다" << endl;
}
catch (int e) {
	cout << "오류: 사람이 " << e << " 명입니다." << endl;
}

4. 템플릿, 클래스템플릿 (만들라고 나올수도있음)

 

❤️

1.다양한 타입의 객체에 대해 하나의 형틀을 만들어서 코드를 재사용하는 것임 2. 클래스, 함수 ~등등 생성 전까진 코드 생성이 안됨 (코드 증가 시키지 않음) 3. STL 이라는 템플릿 기반의 라이브러리가 제공돼서 우수함 ⇒ 함수템플릿만있으면 원하는 형 생성가능 (함수오버로딩) ⇒

 

Copy

//함수 템플릿
template <typename 타입이름>
함수의 원형
{
	....// 함수의 본체
}


//클래스 템플릿
template <typenmae T>
class 클래스이름
{
	...// T를 어디서든 사용 가능
}

Copy

template <typename T>
T get_sum(T x)
{
	x = x + 10;
	return x;
}
template <typename T>
T get_sum(T x, T y)
{
	if (x > y) return x;
	else return y;
}
int main()
{
	cout << get_sum(3) << endl;
	cout << get_sum(1.2, 3.9) << endl;
	return 0;
}

Copy

#include <iostream>
using namespace std;

template <typename T>
class Box {
T data; // T는 타입(type)을 나타낸다.
public:
Box() { }

void set(T value) {
data = value;
}

T get() {
return data;
}
------------------------------------
int main()
{
Box<int> box; // 구체화 
box.set(100);
cout << box.get() << endl; //100

Box<double> box1;
box1.set(3.141592);
cout << box1.get() << endl; //3.14~

return 0;
}

 

 

 

 

5. STL

❤️

컨테이너 + 반복자 + 알고리즘 STL 알고리즘은 반복자를 통하여 컨테이너에 접근하여 작업을 한다. ◼ STL은 프로그래밍에 매우 유용한 수많은 컨테이너와 알고리즘을 제공 ◼ STL은 객체 지향 기법과 일반화 프로그래밍 기법을 적용하여서 만들어졌으므로 어떤 자료형에 대해서도 사용가능 ◼ STL은 전문가가 만들어서 테스트를 거친 검증된 라이브러리

 

 

1. 알고리즘

 

find() 와 find_if()

count()

 

#include<algorithm>
int main()
{
vector<string> vec { "사과", "토마토", "배", "수박", "키위" };
auto it = find(vec.begin(), vec.end(), "수박");
if (it != vec.end())
cout << "수박이 " << distance(vec.begin(), it) << "에 있
습니다." << endl;
return 0;
}

#include<algorithm>
template <typename T>
bool is_even(const T& num)
{
return (num % 2) == 0;
}
int main()
{
vector<int> vec;
for (int i = 0; i<10; i++)
vec.push_back(i);
size_t n = count_if(vec.begin(), vec.end(), is_even<int>);
cout << "값이 짝수인 요소의 개수: " << n << endl;
return 0;

binary_search()

for_each()

bool comp(string s1, string s2) {
return (s1 == s2);
}
int main(void) {
vector<string> v = { "one", "two", "three" };
bool result;
result = binary_search(v.begin(), v.end(), "two", comp);
if (result == true)
cout << "문자열 \"two\" 은 벡터 안에 있음." << endl;
return 0;
}

void printEven(int n) {
if (n % 2 == 0)
cout << n << ' ';
}
int main(void) {
vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
for_each(v.begin(), v.end(), printEven);
cout << endl;
return 0;
}

2.컨테이너 자료를 저장하는 창고 종류에 따라 입출력 방법이 달라진다.

1.순차 컨테이너 = 시퀀스: ▪ 자료를 순차적으로 저장

◼ 벡터(vector): 동적 배열처럼 동작한다. 뒤에서 자료들이 추가된다. (동적 배열 , 스마트배열)

◼ 리스트(list): 벡터와 유사하지만 중간에서 자료를 추가하는 연산이효율적이다.

Copy

//리스트 

#include <list>
using namespace std;
int main()
{
list<int> my_list={ 10, 20, 30, 40 };
auto it = my_list.begin();
it++;
it++;
my_list.insert(it, 25);
for (auto& n : my_list)
cout << n << " ";
cout << endl
return 0;
}

 

◼데크(dequ): 벡터와 유사하지만 앞에서도 자료들이 추가될 수 있다

Copy

//덱 문자열 연산

#include <iostream>
#include <deque>
using namespace std;
int main()
{
deque<int> dq = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
dq.pop_front(); // 앞에서 삭제
dq.push_back(11); // 끝에서 추가
for (auto& n : dq)
cout << n << " ";
cout << endl;
return 0;
}

Copy

//덱 연산

#include <iostream>
#include <deque>
using namespace std;
int main()
{
deque<int> dq = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
dq.pop_front(); // 앞에서 삭제
dq.push_back(11); // 끝에서 추가
for (auto& n : dq)
cout << n << " ";
cout << endl;
return 0;
}

2. 연관 컨테이너 = 연관시퀀스: ▪ 사전과 같은 구조를 사용하여서 자료를 저장 ▪ 원소들을 검색하기 위한 키(key) ▪ 자료들은 정렬

◼ 집합(set): 중복이 없는 자료들이 정렬되어서 저장된다.

Copy

#include <set>
int main()
{
set<int> my_set;
my_set.insert(1);
my_set.insert(2);
my_set.insert(3);
auto pos = my_set.find(2);
if (pos != my_set.end())
cout << "값 " << *pos << "가 발견되었음" << endl;
else
cout << "값이 발견되지 않았음" << endl;
return 0 ;
}

◼ 맵(map): 키-값(key-value)의 형식으로 저장된다. 키가 제시되면 해당되는 값을 찾을 수 있다

키와 값으로 이루어져있음 (각각의 딕셔너리와)

영어사전 구현함, 단어를 받아서 단어의 설명을 출력함

Copy

#include <iostream>
#include <string>
#include <map>
using namespace std;
int main()
{
string word;
map<string, string> dic;
dic["boy"] = "소년";
dic["school"] = "학교";
dic["office"] = "직장";
dic["house"] = "집";
dic["morning"] = "아침";
dic["evening"] = "저녁";

while (true) {
	cout << "단어를 입력하시오: ";
	cin >> word;
	if (word == "quit") break;
	string meaning = dic[word];
	if (meaning != "")
	cout << word << "의 의미는 " << meaning << endl;
}
return 0;
}

Copy

#include <iostream>
#include <map>
#include <string>
#include <iterator>
using namespace std;
int main()
{
map<string, string> myMap;
myMap.insert(make_pair("김철수", "010-123-5678"));
myMap.insert(make_pair("홍길동", "010-123-5679"));
myMap["최자영"] = "010-123-5680"
// 모든 요소 출력
for(auto& it : myMap){
cout << it.first << " :: " << it.second << endl;
}
if (myMap.find("김영희") == myMap.end())
cout << "단어 '김영희'는 발견되지 않았습니다. " << endl;
return 0;
}

3. 컨테이너 어댑터 ▪ 순차 컨테이너에 제약을 가해서 데이터들이 정해진 방식으로만 입출력

◼ 스택(stack): 먼저 입력된 데이터가 나중에 출력되는 자료 구조 (선입후출)

Copy

#include <stack>
int main()
{
stack<string> st;
string sayings[3] =
{ "The grass is greener on the other side of the fence",
"Even the greatest make mistakes",
"To see is to believe" };
for (auto& s : sayings)
st.push(s);
while (!st.empty()) {
cout << st.top() << endl;
st.pop();
}
return 0;
}

◼ 큐(queue): 데이터가 입력된 순서대로 출력되는 자료 구조 (선입선출) ◼ 우선 순위큐(priority queue): 큐의 일종으로 큐의 요소들이 우선 순 위를 가지고 있고 우선 순위가 높은 요소가 먼저 출력되는 자료 구조

Copy

include<queue>
int main()
{
queue<int> qu;
qu.push(100);
qu.push(200);
qu.push(300);
while (!qu.empty()) {
cout << qu.front() << endl;
qu.pop();
}
return 0;
}

 

3.반복자

일반화된 포인터(generalized pointer) / 알고리즘은 반복자를 통하여 컨테이너에 접근하여 작업을 한다.

요소를 순차적으로 처리하기위한 컴포넌트 (for 문에서의 i 는 반복자임

• Begin() : 맨 처음부터
• end() : 맨 끝에서부터
• ++ 컨테이너 다음요소
• - - 이전요소
• = , ! = 같은 요소를 가리키고 있는지 확인
• * 반복자가 가리키는 요소값을 추출하기 위한 역참조 연산자

 

Copy

//학생들의 성적을 저장하는 벡터를 생성해서

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

int main() {
vector<double> scores (10);
for (int i=0; i<scores.size(); i++)
{
cout<<"성적을 입력하시오:";
cin >> scores[i];
}

double highest =scores[0];
for(int i = 1; i<scores.size(); i++)
	if (scores[i] > highest)
		 highest = scores[i];
cout<<"최고 성적은" << highest << "입니다 \n";

return 0;
}

Copy

#include <iostream>
#include<vector>
using namespace std;
int main()
{
vector<double> scores;
while (true) {
double value = 0.0;
cout << "성적을 입력해 주세요 :(-1을 치면 종료) ";
cin >> value;
if (value < 0.0) break;
scores.push_back(value);
}
double highest = scores[0];
vector<double>::iterator it;
for(it = scores.begin(); it < scores.end(); it++)
if (*it > highest)
highest = *it;
cout << "최고의 성적은" << highest << "입니다." << endl;
return 0;
}

Copy

//5보다 큰 정수
bool is_greater_than_5(int value)
{
return (value > 5);
}
int main()
{
vector<int> numbers{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
auto count = count_if(numbers.begin(), numbers.end(),is_greater_than_5);
cout << "5보다 큰 정수들의 개수: " << count << endl;
return 0;
}

 

 

6. 람다식 & auto 함수

❤️

이름이 없는 함수개체, 내포되는 함수 람다식을 사용하면 코드가 간결해짐 auto함수는 타입 추론 방식

 

Copy

//람다식
#include <iostream>
using namespace std;
int main()
{
auto sum = [](int x, int y) { return x + y; };
cout << sum(1, 2) << endl;
cout << sum(10, 20) << endl;
return 0;
}

 

7. 다형성(polymorphism)이란

❤️

타입이 다르면 서로 다른 동작을함 객체 지향 기법에서 하나의 코드로 다양한 타입의 객체를처리하는 중요한 기준 ⇒ 객체 포인터 (형변환) 을 통해서 이루어짐

8. 상향/하향 형변환

❤️

자식 클래스 중 부모클래스로 상속 받은 부분만 ! 부모클래스포인터로 가리킬수있음!!!!!! → 하향형변환하는이유 -상향 형변환(upcasting): 객체포인터가 부모 가리킴 자식 클래스 타입을 부모 클래스타입으로 변환 -하향 형변환(downcasting): 부모 클래스 타입을 자식 클래스타입으로 변환 포인터는 상속된(Derived) 클래스의 객체만을 가리킬 수 있음

Copy

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

class RemoteControl {

public:
    virtual void turnOn() = 0;
    virtual void turnOff() = 0;
};

class Television : public RemoteControl {
public:
    void turnOn() {
        cout << "tv on" << endl;
    }
    void turnOff() {
        cout << "tv off" << endl;
    }
    void volCh() {
        cout << "vol ch" << endl;
    }

};
class Radio : public RemoteControl {
public:
    void turnOn() {
        cout << "tv on" << endl;
    }
    void turnOff() {
        cout << "tv off" << endl;
    }
    void volAMFM() {
        cout << "AMFM ch" << endl;
    }
};
void main() {

    RemoteControl* r1 = new Television(); 
    r1->turnOn();

    RemoteControl* r2 = new Radio();
    r2->turnOn();

    //r1->volCh(); 부모에 없는 것은 하향형변환을해줘야됨  ㅇㅇ당연함
    ((Television*)r1)->volCh(); 

    /*void volCh() {
    cout<<"RemoteControl vol ch"<<endl;
    } 아님 부모 클래스에 추가 ㄱ */

    return;
}

Copy

class Shape {
protected:
int x, y;

public:
void setOrigin(int x, int y){
this->x = x;
this->y = y;
}
void draw() { 
cout <<"Shape Draw";
}
};

class Rectangle : public Shape {
private: 
int width, height;
public: 
void setWidth(int w) {
width = w;
}
void setHeight(int h) {
height = h;
}
void draw() {
cout << "Rectangle Draw";
}
}


class Circle : public Shape {
private: 
int radius;
public: 
void setRadius(int r) {
radius = r;
}
void draw() {
cout << "Circle Draw"<< endl;
}
};


void main() {

    //Shape* pa = new Shape();//본래 동적 객체생성
    //pa->draw(); 

    Shape* pb = new Rectangle();//상향형변환 부모
    pb->draw();

    ((Rectangle*)pb) -> draw () ;// 하향형변환 자식

    delete pb;

    return;
}

Copy

class Shape {
...
}
class Rectangle : public Shape {
...
}
int main()
{
Shape *ps = new Rectangle(); // 상향 형변환
//여기서 ps를 통하여 Rectangle의 멤버에 접근하려면
ps->setOrigin(10, 10);
ps->draw(); //Shape 포인터이기 때문에 Shape의 draw()가 호출
1. Rectangle *pr = (Rectangle *) ps;
2.((Rectangle *)ps)-> draw(); // 하향 형변환
delete ps;

UML +

클래스명 / 속성 (특징,변수) / 연산(메서드)

-private +public #protected

분석단계의 UML 과 설계 단계의 UML이 다름

 

 

 

 

 

9. virtual 가상함수

❤️

자식 클래스 객체를 부모 클래스 객체로 취급하면 서로다른 종류를 호출하는데 유용함 (부모를 가리켜도 자식을 반환함) 이때!!! 특히 공용으로 사용되는 함수들 가상함수로 쓰면 좋음 ⇒ ps가 실제로 가리키고 있는 객체 타입에 따라 재정의된 함수가 호출(자식)됨 ⇒ 멤버함수에만 사용 가능, 멤버변수에는 사용 불가 ⇒부모클래스에서 virtual이면 자식클래스에서는 virtual을 사용하지 않더라도 자동으로 virtual ⇒ 부모클래스(Shape)의 포인터(ps)로 호출을 하더라도, 자식클래스(Rectangle)의재정의된 함수 draw()가 호출되게 하려면, 부모클래스에서 함수 draw()를 가상함수로 정의하면 된다

 

Copy

#include <iostream>
#include <string>
using namespace std;
class Shape {
protected:
int x, y;
public:
void setOrigin(int x, int y){
this->x = x;
this->y = y;
}
virtual void draw() {  //가상 함수 정의
cout <<"Shape Draw" << endl;
}
};
class Rectangle : public Shape { //재정의
void draw() {
cout << "Rectangle Draw" << endl;
}
int main()
{
Shape *ps = new Rectangle();
ps->draw(); // rectangle draw()
delete ps;
Shape *ps1 = new Circle();
ps1->draw();
delete ps1;
return 0;

//모든 도형을 부모클래스 포인터로 가리키고 이 포인터로 
//draw() 함수를 호출하면 재정의된 함수가 호출됨 (virtaul)
}

Copy

#include<iostream>
#include<list>
using namespace std;
class Shape {
protected:
    int x, y;
public:
    void setOrigin(int x, int y) {
        this->x = x;
        this->y = y;
    }
    virtual void draw() { // 가상함수 
        cout << "Shape Draw" << endl;
    }
};

class Rectangle : public Shape {
protected:
    int width, height;
public:
    void setWidth(int w) {
        this->width = w;
    }
    void setHegith(int h) {
        this->height = h;
    }
    void draw() {
        cout << "Rectangle Draw" << endl;
    }
};

class Circle : public Shape {
protected:
    int radius;
public:
    void setRadius(int r) {
        this->radius = r;
    }
    void draw() {
        cout << "Circle Draw" << endl;
    }
};

void main() {

    Shape* pc = new Shape();//객체생성
    pc->draw();
    //Shape draw()

    Shape* pb = new Rectangle();
    pb->draw(); //가상함수로 rectangle 의 draw () 

    Shape* pa = new Circle();
    pa->draw(); //가상함수로 circle 의 draw () 

    Rectangle* pr = (Rectangle*)pb; //하향형변환1
    pr->draw(); 
    // rectangle draw()
    ((Rectangle*)pb)->draw();//하향형변환1  
    // rectangle draw()

/*
Rectangle r1;
Shape &s1 = r1;
s1.draw(); 
*/


    return;
}

Copy

다형성을 사용하는 과정에서 소멸자를 virtual로 해주지 않으면 문제가 발생한다.
  (예제) String 클래스를 상속받아서 각 줄의 앞과 뒤에 헤더를 붙이는 MyString 이라는 클래스를 정의하여 보자.
  String 클래스는 내부에 문자열을 저장하기 위해 char 배열을 동적으로 생성한다.
  소멸자에서는 이 동적으로 생성된 공간을 반납한다.

10. 바인딩 =가상함수가 있으면 동적 바인딩임

❤️

바인딩 : 함수 호출을 함수의 몸체와 연결하는 것 정적바인딩 : 컴파일 단계에서 모든 바인딩이완료 되는 것 동적바인딩 = 지연바인딩 : 바인딩 실행시까지 지연되고 실제 호출되는 함수를 결정 (⇒동적바인딩을 사용하면 다형성을 구현)

Copy

class Triangle: public Shape {
private: 
int base, height;
public: 
void draw() {
cout << "Triangle Draw" << endl;
}
};
int main() {
	Shape *arrayOfShapes[3];
	arrayOfShapes[0] = new Rectangle();
	arrayOfShapes[1] = new Triangle();
	arrayOfShapes[2] = new Circle();
	for (int i = 0; i < 3; i++) {
	arrayOfShapes[i]->draw();
	}
}

 

Copy

#include <iostream>
using namespace std;
class Animal 
{
public: 
virtual void speak() { cout <<"Animal speak()" << endl; }
};

class Dog : public Animal 
{
public: 
void speak() { cout <<"멍멍" << endl; }
};

class Cat : public Animal 
{
public: 
void speak() { cout <<"야옹" << endl; }
};

int main()
{
Dog d;
Animal &a1 = d;
a1.speak();
Cat c;
Animal &a2 = c;
a2.speak();
return 0;
}

11. 가상소멸자

❤️

상향형변환시에 부모 소멸자에 가상소멸자 해줘야됨

Copy

//다형성 사용시 소멸자 virtual 로 안하면
//Parent() 소멸자 동작
//Child() 소멸자 동작 안함


#include <iostream>
using namespace std;

class Parent
{
public:
//~Parent() { cout << "Parent 소멸자" << endl; }
virtual ~Parent() { cout << "Parent 소멸자" << endl;}
};

class Child : public Parent
{
public:
~Child() { cout << "Child 소멸자" << endl; }
};

int main()
{
Parent* p = new Child(); // 상향 형변환
delete p;
}

 

12. 순수 가상함수 ⇒ 추상클래스!!

❤️

함수 헤더만 존재하고 함수의 몸체는 없는 함수임 ㅇㅇ

❤️

추상클래스 : 순수 가상함수를 하나라도 가지고 있으면 추상클래스임 추상적인 개념을 표현하는데 적당함 ⇒ 객체 선언 안됨 ⇒ 추상 클래스를 상속 받으면 재정의 해줘야함

Copy

virtual 반환형 함수이름 (매개변수 리스트)  = 0;

virtual voud draw() = 0;

Copy

class Shape {
protected:
int x, y;
public:
…
virtual void draw() = 0; //순수 가상함수
};

class Rectangle : public Shape {
private: 
int width, height;
public: 
void draw() {
cout << "Rectangle Draw" << endl;
}
};

int main()
{
Shape *ps = new Rectangle(); // OK!
ps->draw(); // Rectangle의draw()가호출된다. 
delete ps;
return 0;
}

 

Copy

class Animal {
virtual void move() = 0;
virtual void eat() = 0;
virtual void speak() = 0;
};
class Lion : public Animal {
void move(){
cout << "사자의 move() << endl;
}
void eat(){
cout << "사자의 eat() << endl;
}
void speak(){
cout << "사자의 speak() << endl;
}
};

Copy

class RemoteControl {
// 순수가상함수정의
virtual void turnON() = 0; // 가전제품을켠다.
virtual void turnOFF() = 0; // 가전제품을끈다.
}

class Television : public RemoteControl {
void turnON() 
{
// 실제로TV의전원을켜기위한코드가들어간다.
...
}
void turnOFF()
{
// 실제로TV의전원을끄기위한코드가들어간다.
...
}
}

int main()
{
RemoteControl* r1 = new Television();
r1->turnOn();
RemoteControl* r2 = new Radio();
r2->turnOn();
((Television*)r1)->volCh();
((Radio*)r2)->volAMFM();
delete r1;
delete r2;
return 0;
}

 

13. 스트림, 입출력(파일 읽고 쓰기)

❤️

#스트림 :: 순서가 있는 데이터의 연속적인 흐름 ofstream 읽고 쓰는 ifstream 읽고 출력

Copy

//입력
ifstream is;
is.open("score.txt");
int number;
is >> number;
//출력
ofstream os;
os.open("result.txt");
os << number

//score.txt
20100001 홍길동 100
20100002 김유신 90
20100003 강감찬 80
//Result.txt
20100001 홍길동 100

Copy

c > 사용자 > 자신컴퓨터이름 > source > repos > project

#include<iostream>
#include<fstream>

using namespace std;

int main() {
	int number;
	char name[30];
	int score;

	ifstream is;
	is.open("input.txt");

	if (!is) {
		cerr << " 파일 오픈에 실패 " << endl;
		exit(1);
		// 문제생기면 알려줌
	}

	is >> number >> name >> score; //is에 값들이 들어감(하나) 파일읽음

	ofstream os; // 
	os.open("result.txt");
	
		os << number << " " << name << " " << score << endl; // 쓰는부분에 띄어쓰기해주면됨
		is >> number >> name >> score;

		os << number << " " << name << " " << score << endl;

	is.close();
	os.close();

	return 0;
}


//실행시키면 result 파일 생기면서 하나가 들어가있음

Copy

#include<iostream>
#include<fstream>

using namespace std;

int main() {
	int number;
	char name[30];
	int score;

	ifstream is;
	is.open("input.txt");

	if (!is) {
		cerr << " 파일 오픈에 실패 " << endl;
		exit(1);
		// 문제생기면 알려줌
	}



	ofstream os; // 
	os.open("result.txt");
	for (int i = 0; i < 3; i++) { //자기 값 범위 넘지 않기
		is >> number >> name >> score; //is에 값들이 들어감(하나) 파일읽음
		os << number << " " << name << " " << score << endl; // 쓰는부분에 띄어쓰기해주면됨
	}
	is.close();
	os.close();

	return 0;
}

Copy

//파일 쓰기

int main()
{
ofstream os{ "numbers.txt" };
if (!os) {
cerr << "파일 오픈에 실패하였습니다" << endl;
exit(1);
}
for(int i=0;i<100; i++)
os << i <<" ";
return 0;
// 객체 os가 범위를 벗어나면 ofstream 소멸자가 파일을 닫는다.

Copy

int main()
{
ofstream os{ "numbers.txt" };
if (!os) {
cerr << "파일 오픈에 실패하였습니다" << endl;
exit(1);
}
for(int i=0;i<100; i++)
os << i <<" ";
return 0;
// 객체 os가 범위를 벗어나면 ofstream 소멸자가 파일을 닫는다.
}

 

Copy

//파일모드 예제
int main()
{
using namespace std;
ofstream os(“input.txt", ios::app);
if (!os)
{
cerr << "파일 오픈에 실패하였습니다" << endl;
exit(1);
}
os << "추가되는 줄 #1" << endl;
os << "추가되는 줄 #2" << endl;
return 0;
}

Copy

#include<iostream>
#include<fstream>

using namespace std;

int main() {
	
	ofstream os{ "input.txt", ios::app }; //app는 뒤에 값에 추가 
		//초록색은 예약어 
		if (!os) {
			cerr << "파일오픈 실패" << endl;
			exit(1);
	}

	os << "추가 줄 #1" << endl;
	os << "추가 줄 #2" << endl;

	os.close();

}

Copy

#include<iostream>
#include<fstream>

using namespace std;

int main() {
	
	ifstream is { "input.txt"}; //app는 뒤에 값에 추가 
		//초록색은 예약어 
		if (!is) {
			cerr << "파일오픈 실패" << endl; //cerr 에러코드잡을때
			exit(1);
	}
		int hour;
		double temp;
		while (is >> hour >> temp) {
			cout << hour << "시 : 온도 :" << temp << endl;
		}
	is.close();

}

Copy

//데이터 처리 예제

#include <iostream>
#include <fstream>
using namespace std;
int main()
{
ifstream is{ “input.txt" };
if (!is) { // ! 연산자 오버로딩
cerr << "파일 오픈에 실패하였습니다" << endl;
exit(1);
}
int hour;
double temperature;
while (is >> hour >> temperature) {
cout << hour << "시: 온도 "<< temperature << endl;
}
return 0;
}

//벡터 이용 예제

#include<vector>
class TempData {
public:
int hour;
double temperature;
};
int main()
{
ifstream is{ “input.txt" };
if (!is) { // ! 연산자 오버로딩
cerr << "파일 오픈에 실패하였습니다" << endl;
exit(1);
}
vector<TempData> temps;

int hour;
double temperature;
while (is >> hour >> temperature) {
temps.push_back(TempData{ hour, temperature });
}
for ( TempData t : temps) {
cout << t.hour << "시: 온도 " << t.temperature << endl;
}
return 0;
}

Copy

#include<iostream>
#include<list>
#include<iostream>
#include<fstream>

using namespace std;


void main() {


    ifstream is{ "input.txt" };
    ofstream os{ "output.txt" , ios::app}; /

    if (!is) {
        cerr << "파일오픈실패" << endl;
        exit(1);
    }

    int hour;
    double temp;

    while (is >> hour >> temp) {
        os << hour << "시 : 온도 :" << temp << endl;
    }
    is.close();
    os.close();


    //읽고 쓰기 (input 에서 읽고 output 에서 쓰기)

    return;
}

Copy

#include<vector>

int main (){

class TempData{
public:
		int hour;
		double temp;
}
	ifstream is { "input.txt"}; //app는 뒤에 값에 추가 
		//초록색은 예약어 
		if (!is) {
			cerr << "파일오픈 실패" << endl; //cerr 에러코드잡을때
			exit(1);
	}
vector< TempData > temps; //클래스 자체를 집어넣을 수 있음

		int hour;
		double temp;
		while (is >> hour >> temp) {
			temps.push_back(TempData {hour,temp});
		}

for(TempData t:temps) //반복자
	cout<<t.hour<<"시:온도"<<t.temp<<endl;

	is.close();


return 0;
}



벡터를 만들어서 값을 가져와서 값을 집어 넣음
벡터에 다 집어넣음 시간 온도 시간 온도 시간 온도
클래스라서 & 빠짐 (반복자)를 통해 값을 가져옴

Copy

#include<vector>

int main (){

class TempData{
public:
		int hour;
		double temp;
}


	ifstream is { "input.txt"}; //소스파일과 같이 있는 경로에이ㅆㅇ야함
		//초록색은 예약어 
		if (!is) {
			cerr << "파일오픈 실패" << endl; 
			exit(1);
	}

int num;
while (is){
is>>num;
cout<<num << " ";
}

cout << endl;
is.close();

return 0;
}

14. 좌표(절대경로/상대경로)

함수에 파일명만 지정하면 현재 작업 디렉터리(working directory)에서 파일을 연다

Copy

fopen("hello.txt", "w") 현재 파일 오픈
- 절대 경로 : ifstream is("c:\\in\\input");
- 상대 경로 : ifstream is{"in\\input.txt"};
							상대 경로는 작업 디렉터리를 기준의 파일
- 상대경로 기준 ..\\ 는 부모디렉토리를 뜻함
• ifstream is{ "..\\in\\input.txt" };
- 

리눅스 및 OS X는 경로를 표현할 때 \ 대신 /를 사용
• fopen("/home/project/hello.txt", "w");


..\\
..\\..\\

 

15. 프랜드

❤️

외부의 클래스나 함수가 자신의 내부 데이터에 접근할 수 있도록 허가하는 특수한 함수 프렌드 함수의 원형은 클래스 안에 포함 그 클래스의 모든 멤버함수는 자신의 내부 데이터를 참조할 수 있다. ◼ 함수의 원형에서만 사용 ◼ 하지만 멤버 함수는 아니다. ◼ 프렌드 함수의 본체는 외부에서 따로 정의 ◼ 프렌드 함수는 클래스 내부의 모든 멤버 변수,함수를 사용,호출 가능 ⇒ 두 객체를 비교할때 사용

Copy

class MyClass
{
	friend void sub();
//friend 클래스이름 함수이름(매개변수목록);
...
};

Copy

#include <iostream>
#include <string>
class Company {
private:
	int sales;
	int profitl
// sub()는Company의 전용멤버에 접근할 수 있다. 
pubilc:
	friend void sub(Company& c);

company() : sales(0), profit(100) {}

}; //컴퍼니 안에 친구 만듬

void sub(Company& c) { //c객체가  접근가능하니 실행됨
cout<< c.profit << endl;
}

int main {

Company c1; //실행시키면서
sub(c1); // 객체 집언허음녀

return 0;
}

 

소량의 메모리 : 스택 메모리 / 빠르다

대량의 메모리 : 힙 메모리 / 광활한 메모리 사용가능