OOP final exams

2024-2, CSE103-00 - 오프라인 수업

아래의 main 함수가 설명과 같이 동작하도록, 문제의 클래스와 함수를 1개의 소스 파일(학번.cpp)로 작성하고(main 포함), 소스 파일을 upload하고, 답안지에 작성된 코드의 설명을 작성하여 제출한다. (문제지, cheating sheet 모두 제출)

[채점 기준]

   1.     실행되지 않으면 0점 처리, 주석 처리된 것은 채점하지 않음

   2.     주어진 제한 조건을 위반하면 0점 처리

   3.     문제(main 함수의 내용)를 수정하면 0점 처리, 동작을 확인하기 위하여 주석 처리는 가능

   4.     일반적인 동작이 불가능한 경우 0점 처리 또는 감점(일반적인 입력에 대한 처리 등)

   5.     연산자의 사용이 부정확한 경우 감점(예, &&를 사용할 위치에 &를 사용 등)

   6.     필요 없는 파라메터나 반환이 있으면 감점

   7.     답안지에 코드 동작에 대한 설명이 없으면 0점 처리

int main() {

     std::cout << "### 1 ###" << std::endl;

     // 1. 아래의 조건을 만족하는 A 클래스를 정의하라.

     // 1개의 데이터 멤버(data member, private 접근 권한의 x)를 가진다.

     // 1개의 생성자(constructor, x를 초기화), 1개의 GetX 멤버 함수(member function, x를 반환)를 가진다.

     // 설명되지 않은 멤버는 추가할 수 없다.

     const A a1, a2{ 10. }, a3{ 12.5 };

     std::cout << a1.GetX() << ' ' << a2.GetX() << ' ' << a3.GetX() << '\n';

     // 출력: 0 10 12.5

     std::cout << "\n### 2 ###" << std::endl;

     // 2. 아래의 조건을 만족하는 B 클래스와 비멤버(non-member) 연산자(<<)를 정의하라.

     // 1개의 데이터 멤버(private 접근 권한의 x)를 가진다.

     // 1개의 생성자(x를 초기화), GetX 멤버 함수(x를 반환)와 SetX 멤버 함수(x를 수정)를 가진다.

     // 비멤버 연산자(<<)는 x를 출력하며 friend로 지정할 수 없다.

     // 설명되지 않은 멤버는 추가할 수 없다.

     const B b1, b2(10);

     B b3;

     b3.SetX(5);

     std::cout << b1 << ' ' << b2 << ' ' << b3 << '\n';

     // 출력: 0 10 5

     std::cout << "\n### 3 ###" << std::endl;

     // 3. 아래의 조건을 만족하는 C 클래스와 비멤버 연산자(<<)를 정의하라.

     // 3개의 데이터 멤버(private 접근 권한의 name, score, mean)를 가진다.

     // - name은 문자열, score는 실수를 저장하는 벡터(크기는 2)

     // - mean은 두 score 요소의 평균

     // 1개의 생성자(name, score, mean를 초기화)를 가진다.

     // 비멤버 연산자(<<)는 아래의 예와 같이 멤버를 출력하며 friend를 사용한다.

     // 설명되지 않은 멤버는 추가할 수 없다.

     C c1, c2("Thomas", 84), c3("Sophia", 90.5, 75.4);

     std::cout << c1 << ' '  << c2  << ' ' << c3 << '\n';

     // 출력: Anonymous 0 0 0 Thomas 84 0 42 Sophia 90.5 75.4 82.95

     std::cout << "\n### 4 ###" << std::endl;

     // 4. 아래의 조건을 만족하는 Base/Derived 클래스와 비멤버 연산자(<<)를 정의하라.

     // Base 클래스는 1개의 데이터 멤버(private 접근 권한의 x)를 가진다.

     // Base 클래스는 1개의 생성자(x를 초기화)와 1개의 멤버 함수(Get)를 가진다.

     // Base 클래스의 Get 함수는 x를 반환한다.

     // Derived 클래스는 Base 클래스의 파생 클래스(derived class)이다.

     // Derived 클래스는 1개의 데이터 멤버(private 접근 권한의 y)를 가진다.

     // Derived 클래스는 1개의 생성자(x, y를 초기화)와 1개의 멤버 함수(Get)를 가진다.

     // Derived 클래스의 Get 함수는 x와 y의 합을 반환

     // 비멤버 연산자(<<)는 1개만 정의되며 아래의 예와 같이 출력된다.

     // 설명되지 않은 멤버는 추가할 수 없다.

     const std::vector<Base> v1 = { Base(), Base(2) };

     const std::vector<Derived> v2 = { Derived(), Derived(3), Derived(2, 5) };

     for (const Base& b : v1)

            std::cout << b << ' '; // 출력: 0 2

     std::cout << '\n';

     for (const Base& b : v2)

            std::cout << b << ' '; // 출력: 0 3 7

     std::cout << '\n';

     std::cout << "\n### 5 ###" << std::endl;

     // 5. 아래의 조건을 만족하는 Data 클래스 템플릿을 정의하라.

     // Data 클래스 템플릿은 1개의 std::vector 타입의 데이터 멤버(private 접근 권한의 v)를 가진다.

     // Data 클래스는 1개의 생성자와 3개의 멤버 함수(Print, Size, Set)를 가진다.

     // Data 타입의 인스턴스 생성에서 2개의 인수(argument)가 필요하다.

     // - 첫번쨰 argument는 v의 element type이고 두번째 argument는 v의 size이다.

     // Print 함수는 v의 각 요소를 출력한다.

     // Size 함수는 v의 size를 반환한다.

     // Set 함수는 v의 index의 요소의 값을 수정한다.

     // 설명되지 않은 멤버는 추가할 수 없다.

     Data<int, 3> d1;

     Data<double, 5> d2;

     for (int i = 0; i < d1.Size(); ++i)

            d1.Set(i, i);

     for (int i = 0; i < d2.Size(); ++i)

            d2.Set(i, i/2.);

     d1.Print(); // 출력: 0 1 2

     std::cout << '\n';

     d2.Print(); // 출력: 0 0.5 1 1.5 2

     std::cout << '\n';

      std::cout << "\n### 6 ###" << std::endl;

     // 6. 아래의 조건을 만족하는 Fn1 함수를 정의하라.

     // Fn1 함수는 2개의 parameter(f와 t)를 가진다.

     // 반환되는 함수는 f의 결과가 t보다 크거나 같으면 f이며, t보다 작으면 -f인 함수이다.

     // 최대한 간략하게, 함수의 body는 1줄의 return으로 작성한다.

     auto f1 = [](double x) { return 2 * x; };

     auto f2 = [](double x) { return 3 * x * x + 3 * x - 15; };

     auto F1 = Fn1(f1, 0);

     auto F2 = Fn1(f2, 0);

     for (int x = -3; x <= 3; ++x)

            std::cout << F1(x) << ':' << f1(x) << ' ';

     // 출력: 6:-6 4:-4 2:-2 0:0 2:2 4:4 6:6

     std::cout << '\n';

     for (int x = -3; x <= 3; ++x)

            std::cout << F2(x) << ':' << f2(x) << ' ';

     // 출력: 3:3 9:-9 15:-15 15:-15 9:-9 3:3 21:21

     std::cout << '\n';

     std::cout << "\n### 7 ###" << std::endl;

     // 7. 아래의 조건을 만족하는 Fn2 함수를 정의하라.

     // Fn2 함수는 2개의 parameter(v와 t)를 가진다.

     // v의 second가 t보다 크거나 같은 요소를 제거한다.

     // Fn2 함수는 std::vector<...>.erase, std::remove_if와 1개의 lambda 함수만 사용한다.

     // 최대한 간략하게, 함수의 body는 1줄로 작성한다.

     std::vector<std::pair<char, int>> v(10);

     srand((unsigned)time(nullptr));

     for (auto& e : v) {

            e.first = rand() % ('Z' - 'A' + 1) + 'A';

            e.second = rand() % 10;

     }

     for (const auto& e : v)

            std::cout << e.first << ':' << e.second << ' ';

     // 가능한 출력 // L:5 O:3 D:4 V:3 U:0 I:0 Q:8 J:4 R:0 Z:5

     std::cout << '\n';

     Fn2(v, 4);

     for (const auto& e : v)

            std::cout << e.first << ':' << e.second << ' ';

     // 위의 가능한 출력에 대한 출력 // O:3 V:3 U:0 I:0 R:0

}

2024-2, CSE103-02 - 온라인 수업

아래의 main 함수가 설명과 같이 동작하도록, 문제의 클래스와 함수를 1개의 소스 파일(학번.cpp)로 작성하고(main 포함), 소스 파일을 upload하고, 답안지에 작성된 코드의 설명을 작성하여 제출한다. (문제지, cheating sheet 모두 제출)

[채점 기준]

   1.     실행되지 않으면 0점 처리, 주석 처리된 것은 채점하지 않음

   2.     주어진 제한 조건을 위반하면 0점 처리

   3.     문제(main 함수의 내용)를 수정하면 0점 처리, 동작을 확인하기 위하여 주석 처리는 가능

   4.     일반적인 동작이 불가능한 경우 0점 처리 또는 감점(일반적인 입력에 대한 처리 등)

   5.     연산자의 사용이 부정확한 경우 감점(예, &&를 사용할 위치에 &를 사용 등)

   6.     필요 없는 파라메터나 반환이 있으면 감점

   7.     답안지에 코드 동작에 대한 설명이 없으면 0점 처리

int main() {

     std::cout << "### 1 ###" << std::endl;

     // 1. 아래의 조건을 만족하는 A 클래스를 정의하라.

     // 1개의 데이터 멤버(data member, private 접근 권한의 x)를 가진다.

 // 1개의 생성자(constructor, x를 초기화), 1개의 Print 멤버 함수(member function, x 출력)를 가진다.

 // 설명되지 않은 멤버는 추가할 수 없다.

     const A a1, a2{ 5 }, a3{ 10 };  

     a1.Print();

     a2.Print();

     a3.Print();

     std::cout << '\n';

     // 출력: 0 5 10

     std::cout << "\n### 2 ###" << std::endl;

     // 2. 아래의 조건을 만족하는 B 클래스와 비멤버(non-member) 연산자(<<)를 정의하라.

     // 1개의 데이터 멤버(private 접근 권한의 x)를 가진다.

     // 1개의 생성자(x를 초기화), GetX 멤버 함수(x를 반환)와 + 멤버 연산자(x를 더한 객체를 반환)를 가진다.

     // 비멤버 연산자(<<)는 x를 출력하며 friend로 지정할 수 없다.

     // 설명되지 않은 멤버는 추가할 수 없다.

     B b1;

     const B b2(5), b3(10);

     b1 = b2 + b3;

     std::cout << b1 << ' ' << b2 << ' ' << b3 << '\n'; // 출력: 15 5 10

     std::cout << "\n### 3 ###" << std::endl;

     // 3. 아래의 조건을 만족하는 C 클래스를 정의하라.

     // 2개의 데이터 멤버(private 접근 권한의 n1, n2)를 가진다.

     // 1개의 생성자(n1과 n2를 초기화)와 1개의 형변환(int) 멤버 연산자(n1+n2을 반환)를 가진다.

     // 아래 출력은 형변환 연산자가 정의되어 묵시적 변환(implicit conversion)으로 출력된다.

     // 설명되지 않은 멤버는 추가할 수 없다.

     C c1, c2(5), c3(1, 2);

     std::cout << c1 << ' '  << c2  << ' ' << c3 << '\n';    // 출력: 0 5 3

     std::cout << "\n### 4 ###" << std::endl;

     // 4. 아래의 조건을 만족하는 Base와 Derived 클래스를 정의하라.

     // Base 클래스는 1개의 데이터 멤버(private 접근 권한의 x)를 가진다.

     // Base 클래스는 1개의 생성자(x를 초기화)와 한 개의 멤버 함수(Get)를 가진다.

     // Base 클래스의 Get 함수는 x를 반환한다.

     // Derived 클래스는 Base 클래스의 파생 클래스(derived class)이다.

     // Derived 클래스는 1개의 데이터 멤버(private 접근 권한의 y)를 가진다.

     // Derived 클래스는 1개의 생성자(x, y를 초기화)와 1개의 멤버 함수(Get)를 가진다.

     // Derived 클래스의 Get 함수는 x와 y의 합을 반환한다.

     // 설명되지 않은 멤버는 추가할 수 없다.

     const std::vector<Base> v1 = { Base(), Base(2) };

     const std::vector<Derived> v2 = { Derived(), Derived(3), Derived(2, 5) };

     for (const Base& b : v1)

            std::cout << b.Get() << ' '; // 출력: 0 2

     std::cout << '\n';

     for (const Base& d : v2)

            std::cout << d.Get() << ' ';  // 출력: 0 3 7

     std::cout << '\n';

     std::cout << "\n### 5 ###" << std::endl;

     // 5. 아래의 조건을 만족하는 E 클래스 템플릿을 정의하라.

     // E 클래스 템플릿은 3개의 데이터 멤버(private 접근 권한의 x, y, mean)를 가진다.

     // E 클래스는 1개의 생성자와 1개의 Print 멤버 함수를 가진다.

     // 생성자는 x, y를 파라메터로 초기화하고, x와 y의 평균을 mean에 저장한다.

     // Print 함수는 x, y, mean을 순서대로 출력한다.

     // x, y, mean이 char 타입인 경우에는 정수 값으로 출력되도록 explicit specialization 한다.

     // auto 및 표준 함수는 사용할 수 없다.

     // 설명되지 않은 멤버는 추가할 수 없다.

     E<int> e1(10, 20), e2;

     E<double> e3(20.2);

     E<char> e4('A', 'C'); // 'A'는 ASCII 65, 'C'는 ASCII 67

     e1.Print(); // 출력: 10 20 15

     e2.Print(); // 출력: 0 0 0

     e3.Print(); // 출력: 20.2 0 10.1

     e4.Print(); // 출력: 65 67 66

     std::cout << '\n';

     std::cout << "\n### 6 ###" << std::endl;

     // 6. 아래의 조건을 만족하는 Fn1 함수 템플릿을 정의하라.

     // Fn1 함수는 아래의 출력과 같이 container의 모든 요소를 출력한다.

     // auto 및 표준 함수는 사용할 수 없다.

     // 최대한 간략하게, 반복문과 iterator의 연산과 std::cout을 사용한다.

     // 추가적으로 1개의 instance는 사용될 수 있다.

     std::vector<int> x1{ 1, 2, 3, 4 };

     std::vector<double> x2{ 1.5, 2.3, 3.2 };

     std::list<int> x3{ 4, 7, 3, 2 };

     Fn1(x1.begin(), x1.end()); // 출력: 1 2 3 4

     Fn1(x2.begin(), x2.end()); // 출력: 1.5 2.3 3.2

     Fn1(x3.begin(), x3.end()); // 출력: 4 7 3 2

     std::cout << '\n';

     std::cout << "\n### 7 ###" << std::endl;

     // 7. 아래의 조건을 만족하는 Fn2 함수를 정의하라.

     // Fn2 함수는 std::vector<int>에서 0보다 작은 요소를 제거한다.

     // Fn2 함수는 std::vector<int>.erase, std::remove_if와 1개의 사용자 lambda 함수만 사용한다.

     // 최대한 간략하게, 함수의 body는 1줄로 작성한다.

     std::vector<int> z{ 1, 4, -2, 0, 8, -4, 7 };

     for (const auto& e : z)

            std::cout << e << ' '; // 출력: 1 4 -2 0 8 -4 7

     std::cout << '\n';

     Fn2(z);

     for (const auto& e : z)

            std::cout << e << ' ';    // 출력: 1 4 0 8 7

     std::cout << '\n';

}

2024-1, CSE103-00 - 오프라인 수업

/*             Object-Oriented Programming, Final exam (2024-1, CSE103-00)                       */

#include <iostream>

#include <vector>

#include <list>

#include <string>

#include <functional>

#include <algorithm>

#include <numeric> 

#include <exception>

#include <memory>

#include <iterator>

// 학과: 학번: 이름:

// 답안 코드 (함수 및 클래스) 작성 영역

int main() {

// 전역 변수 및 static 변수 사용 금지

// 채점 기준: 1. 실행되지 않으면 0점 처리

// 2. 주어진 제한 조건을 위반하면 0점 처리

// 3. 문제(main 함수의 내용)를 수정하면 0점 처리

// 4. 일반적인 동작이 불가능한 경우 0점 처리 또는 감점(일반적인 입력에 대한 처리 등)

// 5. 연산자의 사용이 부정확한 경우 감점(예, &&를 사용할 위치에 &를 사용 등)

// 6. 필요없는 파라메터나 반환이 있으면 감점

// 7. 답안지에 코드 동작에 대한 설명이 없으면 0점 처리

/**********

1. 모든 문제에서 friend 설정을 할 수 없음

2. 모든 문제에서 데이터 멤버는 private로 선언한다.

3. 모든 문제에서 auto 타입을 사용할 수 없다.

**********/

// 1. 아래 코드에서 주석과 같이 출력되도록 A 클래스를 정의하라.

// 한 개의 private 접근 권한의 데이터 멤버를 가진다(추가적인 데이터 멤버 없음).

// 생성자에 초기값이 없는 경우에는 0으로 초기화 한다.

// 생성자와 GetX만 overloding 없이 한 개씩만 정의한다. 

std::cout << "\n### 1 ###" << std::endl;

// 답안이 작성되면 아래의 /*****와 *****/를 제거하라.(제거하지 않으면 채점하지 않음)

/*****

A a1(1.5), a2;

const A a3(3.2);

std::cout << a1.GetX() << ", " << a2.GetX() << ", " << a3.GetX() << std::endl;

// Print: 1.5, 0, 3.2

*****/

// 2. 아래 코드에서 주석과 같이 출력되도록 B 클래스를 정의하라.

// 한 개의 private 접근 권한의 데이터 멤버를 가진다(추가적인 데이터 멤버 없음).

// 생성자에 초기값이 없는 경우에는 0으로 초기화 한다.

// 생성자, SetX과 << 연산자를 overloding 없이 한 개씩 정의한다. 

// << 연산자는 비멤버로 정의하며, 추가적인 멤버 함수를 1개 더 사용할 수 있다.

std::cout << "\n### 2 ###" << std::endl;

// 답안이 작성되면 아래의 /*****와 *****/를 제거하라.(제거하지 않으면 채점하지 않음)

/*****

B b1(1), b2;

const B b3(3);

b1.SetX(10);

std::cout << b1 << ", " << b2 << ", " << b3 << std::endl;

// Print: 10, 0, 3

*****/

// 3. 아래 코드에서 주석과 같이 출력되도록 C 클래스를 정의하라.

// 한 개의 private 접근 권한의 데이터 멤버를 가진다(추가적인 데이터 멤버 없음).

// 생성자에 초기값이 없는 경우에는 0으로 초기화 한다.

// 생성자, GetX와 += 연산자만 overloding 없이 한 개씩만 정의한다. 

// += 연산자는 멤버로 정의한다.

std::cout << "\n### 3 ###" << std::endl;

// 답안이 작성되면 아래의 /*****와 *****/를 제거하라.(제거하지 않으면 채점하지 않음)

/*****

const C c1(10);

C c2(5), c3;

c3 = c2 += c1;

std::cout << c2.GetX() << ", " << c3.GetX() << std::endl;

// Print: 15, 15

*****/

// 4. 아래 코드에서 주석과 같이 출력되도록 Super와 Sub 클래스를 정의하라.

// 두 개의 클래스는 상속 관계이며, 각각 한 개의 private 접근 권한의 데이터 멤버를 가진다(추가적인 데이터 멤버 없음).

// 생성자에 초기값이 없는 경우에는 0으로 초기화 한다.

// "Super"와 "~Super"의 출력은 Super 클래스에서 출력하며, "Sub"와 "~Sub"의 출력은 Sub 클래스에서 출력한다.

// 생성자, 소멸자, Print 함수만 overloading 없이 정의한다.

std::cout << "\n### 4 ###" << std::endl;

// 답안이 작성되면 아래의 /*****와 *****/를 제거하라.(제거하지 않으면 채점하지 않음)

/*****

Super* p1 = new Sub(1, 2); // Print: "Super" "Sub"

Sub* p2 = dynamic_cast<Sub*>(p1);

p1->Print(); // Print: 1

std::cout << std::endl;

if (p2) p2->Print(); // Print: 1, 2

std::cout << std::endl;

delete p1; // Print: "~Sub" "~Super"

*****/

// 5. 아래 코드에서 주석과 같이 출력되도록 Data 클래스 템플릿을 정의하라.

// 데이터 멤버는 template type의 자료를 저장하는 shared pointer를 사용한다(private 접근 권한이며 추가적인 데이터 멤버 없음)

// 생성자에 초기값이 없는 경우에는 0을 저장한다.

// Get과 Set은 각각 포인터가 가리키는 대상의 값을 반환하고 수정한다.

std::cout << "\n### 5 ###" << std::endl;

// 답안이 작성되면 아래의 /*****와 *****/를 제거하라.(제거하지 않으면 채점하지 않음)

/*****

Data<int> data1(2), data2;

Data<double> data3(10.5), data4;

std::cout << data1.Get() << ", " << data2.Get() << std::endl; // Print: 2, 0

std::cout << data3.Get() << ", " << data4.Get() << std::endl; // Print: 10.5, 0

data2 = data1;

data2.Set(3);

data3 = data4;

data4.Set(1.2);

std::cout << data1.Get() << ", " << data2.Get() << std::endl; // Print: 3, 3

std::cout << data3.Get() << ", " << data4.Get() << std::endl; // Print: 1.2, 1.2

*****/

// 6. 아래 코드에서 첫 번째 매개변수인 sequence container에서 두 번째 매개변수와 동일한 요소를 제거하는 Function6 템플릿 함수를 정의하라.

// 함수의 body는 한 개의 문장으로 작성하며, container의 메소드와 std::remove 함수만 사용한다.

// std::remove를 사용하지 않고 비효율적으로 작성하면 0점 처리

std::cout << "\n### 6 ###" << std::endl;

// 답안이 작성되면 아래의 /*****와 *****/를 제거하라.(제거하지 않으면 채점하지 않음)

/*****

std::vector<int> v1{ 1, 9, 4, 7, 4, 6 };

Function6(v1, 4);

for (const int& x : v1) std::cout << x << ", "; // Print: 1, 9, 7, 6, 

std::cout << std::endl;

std::list<int> l1{ 8, 3, 4, 3, 3, 2 };

Function6(l1, 3);

for (const int& x : l1) std::cout << x << ", "; // Print: 8, 4, 2,

std::cout << std::endl;

*****/

// 7. 아래의 코드에서 std::vector<int>에서 지정된 값의 요소를 찾는 Function7 함수를 정의하라.

// Function7로 반환된 함수는 return type이 std::vector<int>::iterator이고 parameter type은 std::vector<int>& 이다.

// Fn1은 argument로 전달된 v2에서 2의 값을 가지는 최초의 iterator를 반환하는 함수이고,

// Fn2은 argument로 전달된 v2에서 5의 값을 가지는 최초의 iterator를 반환하는 함수이고,

// Fn2은 argument로 전달된 v2에서 7의 값을 가지는 최초의 iterator를 반환하는 함수이다(찾는 값의 요소가 없으면 end iterator를 반환한다).

// auto 타입을 사용할 수 없으며, container의 메소드와 std::find 함수만 사용한다.

// 반환은 lamba function으로 작성하고, 함수의 body는 return 문장으로만 작성한다.

// std::find를 사용하지 않고 비효율적으로 작성하면 0점 처리

std::cout << "\n### 7 ###" << std::endl;

// 답안이 작성되면 아래의 /*****와 *****/를 제거하라.(제거하지 않으면 채점하지 않음)

/*****

std::vector<int> v2{ 1, 2, 4, 5, 9 };

std::vector<int>::iterator it;

std::function<std::vector<int>::iterator(std::vector<int>&)> Fn1 = Function7(2);

it = Fn1(v2);

if (it != v2.end()) std::cout << std::distance(v2.begin(), it) << ", " << v2[std::distance(v2.begin(), it)] << ", " << *it << std::endl;

else std::cout << std::distance(v2.begin(), it) << std::endl;

// Print: 1, 2, 2

std::function<std::vector<int>::iterator(std::vector<int>&)> Fn2 = Function7(5);

it = Fn2(v2);

if (it != v2.end()) std::cout << std::distance(v2.begin(), it) << ", " << v2[std::distance(v2.begin(), it)] << ", " << *it << std::endl;

else std::cout << std::distance(v2.begin(), it) << std::endl;

// Print: 3, 5, 5

std::function<std::vector<int>::iterator(std::vector<int>&)> Fn3 = Function7(7);

it = Fn3(v2);

if (it != v2.end()) std::cout << std::distance(v2.begin(), it) << ", " << v2[std::distance(v2.begin(), it)] << ", " << *it << std::endl;

else std::cout << std::distance(v2.begin(), it) << " = " << v2.size() << std::endl;

// Print: 5 = 5

*****/

}

2024-1, CSE103-01 - 온라인 수업

/*             Object-Oriented Programming, Final exam (2024-1, CSE103-01)                       */

#include <iostream>

#include <vector>

#include <list>

#include <string>

#include <functional>

#include <algorithm>

#include <numeric> 

#include <exception>

#include <memory>

#include <iterator>

// 학과: 학번: 이름:

// 답안 코드 (함수 및 클래스) 작성 영역

int main() {

// 전역 변수 및 static 변수 사용 금지

// 채점 기준: 1. 실행되지 않으면 0점 처리

// 2. 주어진 제한 조건을 위반하면 0점 처리

// 3. 문제(main 함수의 내용)를 수정하면 0점 처리

// 4. 일반적인 동작이 불가능한 경우 0점 처리 또는 감점(일반적인 입력에 대한 처리 등)

// 5. 연산자의 사용이 부정확한 경우 감점(예, &&를 사용할 위치에 &를 사용 등)

// 6. 필요없는 파라메터나 반환이 있으면 감점

// 7. 답안지에 코드 동작에 대한 설명이 없으면 0점 처리

/**********

1. 모든 문제에서 friend 설정을 할 수 없음

2. 모든 문제에서 데이터 멤버는 private로 선언한다.

3. 모든 문제에서 auto 타입을 사용할 수 없다.

**********/

// 1. 아래 코드에서 주석과 같이 출력되도록 A 클래스를 정의하라.

// 한 개의 private 접근 권한의 데이터 멤버를 가진다(추가적인 데이터 멤버 없음).

// 생성자에 초기값이 없는 경우에는 0으로 초기화 한다.

// 생성자와 GetX만 overloding 없이 한 개씩만 정의한다. 

std::cout << "\n### 1 ###" << std::endl;

// 답안이 작성되면 아래의 /*****와 *****/를 제거하라.(제거하지 않으면 채점하지 않음)

/*****

A a1(1.5), a2;

const A a3(3.2);

std::cout << a1.GetX() << ", " << a2.GetX() << ", " << a3.GetX() << std::endl;

// Print: 1, 0, 3

*****/

// 2. 아래 코드에서 주석과 같이 출력되도록 B 클래스를 정의하라.

// 한 개의 private 접근 권한의 데이터 멤버를 가진다(추가적인 데이터 멤버 없음).

// 생성자에 초기값이 없는 경우에는 0으로 초기화 한다.

// 생성자와 << 연산자를 overloding 없이 한 개씩 정의한다. 

// << 연산자는 비멤버로 정의하며, 추가적인 멤버 함수를 1개 더 사용할 수 있다.

std::cout << "\n### 2 ###" << std::endl;

// 답안이 작성되면 아래의 /*****와 *****/를 제거하라.(제거하지 않으면 채점하지 않음)

/*****

B b1(1), b2;

const B b3(3);

std::cout << b1 << ", " << b2 << ", " << b3 << std::endl;

// Print: 1, 0, 3

*****/

// 3. 아래 코드에서 주석과 같이 출력되도록 C 클래스를 정의하라.

// 한 개의 private 접근 권한의 데이터 멤버를 가진다(추가적인 데이터 멤버 없음).

// 생성자에 초기값이 없는 경우에는 0으로 초기화 한다.

// 생성자, GetX와 + 연산자만 overloding 없이 한 개씩만 정의한다. 

// + 연산자는 멤버로 정의한다.

std::cout << "\n### 3 ###" << std::endl;

// 답안이 작성되면 아래의 /*****와 *****/를 제거하라.(제거하지 않으면 채점하지 않음)

/*****

const C c1(10);

C c2(5), c3;

c3 = c2 + c1;

std::cout << c1.GetX() << ", " << c3.GetX() << std::endl;

// Print: 10, 15

*****/

// 4. 아래 코드에서 주석과 같이 출력되도록 Base와 Derived 클래스를 정의하라.

// 두 개의 클래스는 상속 관계이며, 각각 한 개의 private 접근 권한의 데이터 멤버를 가진다(추가적인 데이터 멤버 없음).

// 생성자에 초기값이 없는 경우에는 0으로 초기화 한다.

// 생성자와 Print 함수만 overloading 없이 정의한다.

std::cout << "\n### 4 ###" << std::endl; 

// 답안이 작성되면 아래의 /*****와 *****/를 제거하라.(제거하지 않으면 채점하지 않음)

/*****

const Derived derived(2, 3);

derived.Print(); // Print: 2, 3

std::cout << std::endl;

const Base& base = derived;

base.Print(); // Print: 2

std::cout << std::endl;

*****/

// 5. 아래 코드에서 주석과 같이 출력되도록 Super와 Sub 클래스를 정의하라.

// 두 개의 클래스는 상속 관계이며, 각각 한 개의 private 접근 권한의 데이터 멤버를 가진다(추가적인 데이터 멤버 없음).

// 생성자에 초기값이 없는 경우에는 0으로 초기화 한다.

// 생성자, Print 함수만 overloading 없이 정의한다.

std::cout << "\n### 5 ###" << std::endl;

// 답안이 작성되면 아래의 /*****와 *****/를 제거하라.(제거하지 않으면 채점하지 않음)

/*****

Sub sub(1, 2);

Super& super = sub;

super.Print();

std::cout << std::endl; // Print: 1, 2

*****/

// 6. 아래 코드에서 주석과 같이 출력되도록 Data 클래스 템플릿을 정의하라.

// 한 개의 private 접근 권한의 데이터 멤버를 가진다(추가적인 데이터 멤버 없음).

// 생성자에 초기값이 없는 경우에는 0으로 초기화 한다.

// Print 멤버 함수는 데이터 멤버의 값을 출력하며, bool 타입은 true이면 "positive"를 false이면 "negative"를 출력한다.

std::cout << "\n### 6 ###" << std::endl;

// 답안이 작성되면 아래의 /*****와 *****/를 제거하라.(제거하지 않으면 채점하지 않음)

/*****

Data<int> data1(10.2);

Data<double> data2(10.2);

Data<bool> data3(true), data4;

data1.Print(); // Print: 10

data2.Print(); // Print: 10.2

data3.Print(); // Print: positive

data4.Print(); // Print: negative

*****/

// 7. 아래의 코드에서 주석과 간이 출력되도록, 

// 매개변수가 한 개의 double이고 반환 타입이 double인 두 개의 함수를 파라메터로 가지며,

// 두 함수 결과의 평균을 반환하는 함수를 생성하는 Function7 함수를 정의하라.

// Function7은 생성된 함수를 반환하며, 

// 반환은 lamba function으로 작성하고, 함수의 body는 return 문장으로만 작성한다. 

std::cout << "\n### 7 ###" << std::endl;

// 답안이 작성되면 아래의 /*****와 *****/를 제거하라.(제거하지 않으면 채점하지 않음)

/*****

std::function<double(double)> F1 = [](double x) {

return 2. * x * x + 3. * x + 2.;

};

std::function<double(double)> F2 = [](double x) {

return 5. * x + 1.;

};

std::function<double(double)> F3 = Function7(F1, F2);

double x = -0.86;

std::cout << x << ", " << F3(x) << ", " << (F1(x) + F2(x)) / 2. << std::endl;

// Print: -0.86, -1.2004, -1.2004

x = 10.5;

std::cout << x << ", " << F3(x) << ", " << (F1(x) + F2(x)) / 2. << std::endl;

// Print: 10.5, 153.75, 153.75

*****/

}

2023-2, CSE103-00 - 오프라인 수업

/*             Object-Oriented Programming, Final exam (2023-2, CSE103-00)                       */

// Write your answers in Korean or English(답안은 한국어 또는 영어로 작성하시오).

#include <iostream>

#include <vector>

#include <list>

#include <string>

#include <functional>

#include <algorithm>

#include <numeric> 

#include <exception>

#include <cstdlib>

#include <ctime>

// 학과: , 학번: , 성명:        

struct Line {

int Start, End;

Line(int s = 0, int e = 0) : Start(s), End(e) {}

};

/////////// 답안 시작

/////////// 답안 끝

int main() {

// 전역 변수 사용 금지

// 채점 기준: 1. 주어진 제한 조건을 위반하면 감점

// 2. 문제(main 함수의 내용)를 수정하면 감점 

// 3. 일반적인 동작이 불가능한 경우 0점 처리 또는 감점(일반적인 입력에 대한 처리 등)

// 4. 연산자의 사용이 부정확한 경우 감점(예, &&를 사용할 위치에 &를 사용 등)

// 5. 필요없는 파라메터나 반환이 있으면 감점

// 6. 답안지에 코드 동작에 대한 설명이 없으면 0점 처리

// 7. 주석 부분은 채점하지 않음(main의 동작도 주석으로 실행되지 않으면 채점하기 않음)

std::cout << "\n### 1 ###" << std::endl;

// 1. 아래와 같이 동작하는 X1 클래스를 정의하고, << 연산자(non member)를 overloading하라.

// 1) 생성자를 overloading하지 않음, 2) 데이터 멤버는 private 접근 권한, 3) friend 선언 사용 금지, 4) 함수, 변수 및 수식의 사용을 최소화

// X1 x1, x2(5.3);

// const X1 x3(7.2);

// std::cout << x1 << ", " << x2 << ", " << x3 << std::endl; // 출력: 0, 5.3, 7.2, 

std::cout << "\n### 2 ###" << std::endl;

// 2. 아래와 같이 동작하는 B2, D2 클래스를 정의하라. 

// 1) 생성자를 overloading하지 않음, 2) 데이터 멤버는 public 접근 권한, 3) 함수, 변수 및 수식의 사용을 최소화

// D2 d1, d2(2.5, 3.2);

// std::cout << d1.B2::x << ", " << d1.x << ", " << d2.B2::x << ", " << d2.x << std::endl; // 출력: 0, 0, 2.5, 3.2

std::cout << "\n### 3 ###" << std::endl;

// 3. 아래와 같이 동작하는 B31, B32, D3 클래스를 정의하라.

// 1) 생성자를 overloading하지 않음, 2) 데이터 멤버는 private 접근 권한, 3) friend 선언 사용 금지, 4) 함수, 변수 및 수식의 사용을 최소화

// B31* pB31 = new D3(1, 0);

// B32* pB32 = new D3(3, 2);

// static_cast<B31>(*pB31).Print(); // 출력: 1

// static_cast<B32>(*pB32).Print(); // 출력: 2

// pB31->Print(); // 출력: 1, 0,

// pB32->Print(); // 출력: 3, 2, 

std::cout << std::endl;

// delete pB31; // 정상적으로 동작해야 함

// delete pB32; // 정상적으로 동작해야 함

std::cout << "\n### 4 ###" << std::endl;

// 4. 아래와 같이 동작하는 V4, W4 클래스를 정의하라.(+ 연산자는 멤버로 정의)

// 1) 생성자를 overloading하지 않음, 2) 데이터 멤버는 private 접근 권한, 3) friend 선언 사용 금지, 4) 함수, 변수 및 수식의 사용을 최소화

// dynamic_cast를 위해서는 Base 클래스는 한 개 이상의 virtual method를 가져야 함

// W4 w0(1, 2), w1(3, 4), w2;

// V4& v0 = w0;

// V4& v1 = w1;

// V4 v2 = w2;

// w2.Print(); // 출력: 0, 0

try {

// W4 w3 = dynamic_cast<W4&>(v0) + dynamic_cast<W4&>(v1); // {1+3, 2+4}

// w3.Print(); // 출력: 4, 6

// W4 w4 = dynamic_cast<W4&>(v0) + dynamic_cast<W4&>(v2); // catch로 Bad dynamic_cast!(Windows)나 std::bad_cast(Mac) 출력

// w4.Print();

}

catch (std::exception& e) {

std::cout << e.what() << std::endl;;

}

std::cout << "\n### 5 ###" << std::endl;

//5. 아래와 같이 동작하는 X5 클래스 템플릿을 정의하라. (t1은 크기가 5인 int형 벡터(std::vector)로 모두 0으로 초기화, t2는 크기가 10인  char형 벡터(std::vector)로 모두 '*'으로 초기화)

// 1) 생성자를 overloading하지 않음, 2) 데이터 멤버는 private 접근 권한, 3) 함수, 변수 및 수식의 사용을 최소화

// X5<int, 5> t1;

// X5<char, 10> t2('*');

// t1.Print(); // 출력: 0, 0, 0, 0, 0,

// t2.Print(); // 출력: *, *, *, *, *, *, *, *, *, *,

try {

// t1.Set(10, 2); // 2번 index를 10으로 수정

// t2.Set('?', 9); // 9번 index를 '?'로 수정

// t2.Set('+', 10);// 10번 index의 요소는 없으므로, catch로 "index exception" 출력, at 메소드 사용불가

}

catch (std::exception& e) {

std::cout << e.what() << std::endl; // "index exception" 출력

}

// t1.Print(); // 출력: 0, 0, 10, 0, 0,

// t2.Print(); // 출력: *, *, *, *, *, *, *, *, *, ?,

std::cout << "\n### 6 ###" << std::endl;

//6. 아래와 같이 두 함수(f1, f2와 같은 프로토타입(prototype))의 곱셈을 수행하는 함수를 반환하는 Fn6 함수를 정의하라.

// 1) 함수, 변수 및 수식의 사용을 최소화

auto f1 = [](double x1, double x2) { return (x1 + x2) / 2.; };

auto f2 = [](double x1, double x2) { return x1 > x2 ? x1 : x2; };

// auto f = Fn6(f1, f2); // ((x1 + x2)/2.)*(x1 > x2 ? x1 : x2)를 반환하는 함수

// std::cout << f(2, 5) << std::endl; // 출력: 17.5

std::cout << "\n### 7 ###" << std::endl;

// 7. 위에 정의된 struct Line으로 아래와 같이 동작하는 operaotr <<, EraseInvalid(Start<End가 아니면 제거)와  UnionLines(Start는 작은 값, End는 큰 값으로 누적)를 정의하라.

// 1) EraseInvalid 함수는 최대한 간소화하여 작성(Lambda 함수가 포함된 한 개의 문장), 2) UnionLines 함수는 최대한 간소화하여 작성(크기가 0인 경우를 확인하는 코드와 Lambda 함수가 포함된 한 개의 리턴)

// 3) EraseInvalid, UnionLines는 조건문, 반복문의 사용을 최소화하여 표준 함수를 사용할 것

srand((unsigned)time(0));

std::vector<Line> lines;

// std::cout << Line(3, 5) << std::endl; // 출력: (3, 5)

for (int i = 0; i < 10; ++i) {

lines.push_back(Line(rand() % 100, rand() % 100));

}

// for (auto e : lines) std::cout << e << ", "; // 출력 예: (77, 26), (1, 4), (96, 1), (57, 80), (61, 33), (76, 51), (37, 57), (22, 25), (27, 61), (66, 57),

std::cout << std::endl;

// EraseInvalid(lines);

// for (auto e : lines) std::cout << e << ", "; // 출력 예: (1, 4), (57, 80), (37, 57), (22, 25), (27, 61),

std::cout << std::endl;

// Line l = UnionLines(lines);

// std::cout << l << std::endl; // 출력 예: (1, 80)

}

2023-2, CSE103-02 - 온라인 수업

/*             Object-Oriented Programming, Final exam (2023-2, CSE103-02)                       */

// Write your answers in Korean or English(답안은 한국어 또는 영어로 작성하시오).

#include <iostream>

#include <vector>

#include <list>

#include <string>

#include <functional>

#include <algorithm>

#include <cstdlib>

#include <ctime>

// 학과: , 학번: , 성명:        

/////////// 답안 시작

/////////// 답안 끝

int main() {

// 전역 변수 사용 금지

// 채점 기준: 1. 주어진 제한 조건을 위반하면 0점 처리

// 2. 문제(main 함수의 내용)를 수정하면 0점 처리

// 3. 일반적인 동작이 불가능한 경우 0점 처리 또는 감점(일반적인 입력에 대한 처리 등)

// 4. 연산자의 사용이 부정확한 경우 감점(예, &&를 사용할 위치에 &를 사용 등)

// 5. 필요없는 파라메터나 반환이 있으면 감점

// 6. 답안지에 코드 동작에 대한 설명이 없으면 0점 처리

std::cout << "\n### 1 ###" << std::endl;

// 1. 아래와 같이 동작하는 A 클래스를 정의하라. 

// 1) 생성자를 overloading하지 않음, 2) 데이터 멤버는 private 접근 권한, 3) 함수, 변수 및 수식의 사용을 최소화

// A a1, a2(1.2);

// const A a3(2.5);

// std::cout << a1.Get() << ", " << a2.Get() << ", " << a3.Get() << std::endl; // 출력: 0, 1.2, 2.5

std::cout << "\n### 2 ###" << std::endl;

// 2. 아래와 같이 동작하는 B 클래스를 정의하라. 

// 1) 생성자를 overloading하지 않음, 2) 데이터 멤버는 private 접근 권한, 3) 함수, 변수 및 수식의 사용을 최소화

// B b1, b2(1.2);

// const B b3(2.5);

// b1.Get() += 1.5;

// b2.Get() += 2.9;

// std::cout << b1.Get() << ", " << b2.Get() << ", " << b3.Get() << std::endl; // 출력: 1.5, 4.1, 2.5

std::cout << "\n### 3 ###" << std::endl;

// 3. 아래와 같이 동작하는 C 클래스를 정의하라. << 연산자는 비멤버, + 연산자는 멤버로 정의

// 1) 생성자를 overloading하지 않음, 2) 데이터 멤버는 private 접근 권한, 3) 함수, 변수 및 수식의 사용을 최소화

// C c1;

// const C c2(1.2), c3(2.5);

// std::cout << c1 << ", " << c2 << ", " << c3 << std::endl; // 출력: 0, 1.2, 2.5

// C c4 = c3 + c2;

// std::cout << c4 << std::endl; // 출력: 3.7

std::cout << "\n### 4 ###" << std::endl;

// 4. 아래와 같이 동작하는 E와 F 클래스를 정의하라. 

// 1) 생성자를 overloading하지 않음, 2) 데이터 멤버는 private 접근 권한, 3) 함수, 변수 및 수식의 사용을 최소화, 4) friend 선언 없음

// F f1, f2(3);

// const F f3(4, 5);

// std::cout << f1.E::Get() << ", " << f1.Get() << std::endl; // 출력: 0, 1

// std::cout << f2.E::Get() << ", " << f2.Get() << std::endl; // 출력: 3, 1

// std::cout << f3.E::Get() << ", " << f3.Get() << std::endl; // 출력: 4, 5

std::cout << "\n### 5 ###" << std::endl;

// 5. 아래와 같이 동작하는 G와 H 클래스를 정의하라. (g1.Get()의 결과는 2, g2.Get()의 결과는 2+4)

// 1) 생성자를 overloading하지 않음, 2) 데이터 멤버는 private 접근 권한, 3) 함수, 변수 및 수식의 사용을 최소화, 4) friend 선언 없음

// const H h1(2, 4);

// G g1 = h1; 

// const G& g2 = h1;

// std::cout << g1.Get() << ", " << g2.Get() << std::endl; // 출력 : 2, 6

std::cout << "\n### 6 ###" << std::endl;

// 6. 아래와 같이 동작하는 K 클래스 템플릿을 정의하라. (k1은 크기가 5인 int형 벡터(std::vector)로 모두 0으로 초기화, k2는 크기가 10인  char형 벡터(std::vector)로 모두 '*'으로 초기화)

// 1) 생성자를 overloading하지 않음, 2) 데이터 멤버는 private 접근 권한, 3) 함수, 변수 및 수식의 사용을 최소화

// K<int> k1(5);

// K<char> k2(10, '*');

// k1.Print(); // 출력: 0, 0, 0, 0, 0,

// k2.Print(); // 출력: *, *, *, *, *, *, *, *, *, *,

std::cout << "\n### 7 ###" << std::endl;

// 7. 아래와 같이 동작하는 Print와  Fn 함수 템플릿을 정의하라. (Print는 iterator 범위를 출력하고, Fn은 요소가 [0, 100] 범위가 아니면 제거한다.)

// 1) 함수를 overloading하지 않음, 2) Fn 함수는 람다(lambda) 함수를 이용하여 최대한 간소화하여 작성

srand((unsigned)time(0));

std::vector<int> r;

std::list<int> l;

for (int i = 0; i < 10; ++i) {

r.push_back(rand() % 300 - 100);

l.push_back(rand() % 300 - 100);

}

// Print(r.begin(), r.end()); // 출력 예: 5, 197, 77, 97, -55, -39, -23, 192, 64, 33,

// Fn(r);

// Print(r.begin(), r.end()); // 출력 예: 5, 77, 97, 64, 33,

// std::cout << std::endl;

// Print(l.begin(), l.end()); // 출력 예: 2, -38, -37, 87, -88, 126, 185, 122, 89, -88,

// Fn(l);

// Print(l.begin(), l.end()); // 출력 예: 2, 87, 89,

}