상속
class Um : public People {
// 내용
};그냥 클래스 선언할 때 클래스 이름 옆에 : 접근제어자 부모이름 적으면 됩니다.
상속 개념은 다들 아시자나요
접근 지정자에 따라 다른 참조 범위를 가집니다.
public : 어디서든 접근 가능
private : 기반 클래스에서만 접근 가능
protected : 기반 클래스, 파생 클래스에서 접근 가능
protected
public, private 같은 접근제어자 입니다.
상속 관계에서만 접근 가능합니다.
순수 가상 함수
virtual void foo() = 0;함수에 몸체를 정의하는 대신 0을 대입한 것이 특징이다.
추상 클래스
순수 가상함수를 지닌 클래스이다.
추상 클래스는 객체를 생성할 수 없다.
가상 소멸자
class A {
private:
A() {
// ...
}
virtual ~A() {
// ...
}
};소멸자에 virtual 붙이는거
연산자 오버로딩
class Point {
private :
int x, y;
public :
Point(int x_, int y_) {
x = x_;
y = y_;
}
void print() {
cout << "x : " << x << ", y : " << y << "\n";
}
Point operator + (Point& p) {
x = x + p.x;
y = y + p.y;
return Point(x, y);
}
};이런 식으로 클래스 내부에 본인이 원하는 자료형으로 operator 기호 하면
오버로딩이 됩니다
대입 연산자 오버로딩
클래스이름& operator=(const 클래스이름& ref) {
private변수 = ref.변수;
return *this;
}이건 문법이 좀 다른데 클래스이름& 를 붙여주는거 이외엔 똑같다고 보면 된다
클래스 내에 선언한다.
함수 템플릿
간단하게 요약하면 함수 호출을 할 때에 내가 함수의 타입을 지정해주는 것
원래 우리는 타입 다른거 함수에서 쓸려면 이런식으로 함수 오버로딩을 해서 짰었는데요
#include <iostream>
using namespace std;
int Add(int n1, int n2) {
return n1 + n2;
}
double Add(double n1, double n2) {
return n1 + n2;
}
int main(void) {
cout << Add(1, 2) << endl;
cout << Add(1.2, 2.2) << endl;
return 0;
}위의 방식으로 짜게 되면 너무 하드코딩 같고 코딩 허접같으니까 조금 동적으로 짜봅시다
#include <iostream>
using namespace std;
template <typename T>
T Add(T num1, T num2) {
return num1 + num2;
}
int main(void) {
cout << Add<int>(1, 2) << endl;
cout << Add<double>(1.2, 2.2) << endl;
return 0;
}이 코드를 보시면 아래에 함수 호출부에서 , 이런식으로 호출시점에 타입을 지정해주네요
이렇게 템플릿 문법을 활용한다면 코드의 양을 줄이고 조금 더 간지나보입니다.
#include <iostream>
using namespace std;
template <typename T>
T Add(T a, T b)
{
return a + b;
}
int main()
{
cout << Add(1.1, 2.2);
}그리고 타입 선언 귀찮으면 매개변수의 타입이 같다는 전제 하에 타입 선언을 안해도 됩니다.
만약 타입 다르면 명시적으로 선언 해놔야해요
#include <iostream>
using namespace std;
template<typename T1, typename T2>
T2 Add(T1 num1, T2 num2) {
return num1 + num2;
}
int main() {
cout << Add(1, 2.2) << endl;
return 0;
}그리고 이런식으로 템플릿 인자가 여러개가 올 수도 있습니다
여러개가 올 경우엔 타입의 종류만큼 위에 typename 선언해주세요
클래스 템플릿
먼저 이거 시작하기 전에 중요한 점이 함수는 굳이 명시적으로 타입을 선언하진 않아도 되지만
클래스는 무조건 반드시 명시적으로 클래스 선언을 해주어야 한다.
이것도 함수 템플릿이랑 거의 비슷합니다.
template <typename T>
class Data
{
private:
T data_;
public:
Data(T dt);
data(T dt);
T get_data();
};이런식으로 클래스 내의 특정 변수의 타입을 내 맘대로 설정하는 것입니다.
템플릿 인자
template <typename T, int len> // 이런식으로 typename 아니고 int ㄱㄱ
class SimpleArray {
private:
T arr[len];
public:
T& operator[](int idx) {
return arr[idx];
}
SimpleArray<T, len>& operator=(const SimpleArray<T, len>& ref) {
for (int i = 0; i < len; i++) {
arr[i] = ref.arr[i];
}
return *this;
}
};
// 실제 호출할 때는 이렇게
SimpleArray<int, 5> i5arr1;이건 좀 신기한데 템플릿 문법으로 타입 대신 값 을 전달해주는 문법입니다. 그게 끝임
예외처리
try catch로 예외처리 하는거구요,
try
{
cin >> num1;
cin >> num2;
if(어딘가 하자있으면) {
throw num1; // int throw
}
if(어딘가 하자있으면2) {
throw num2; // char throw
}
}
catch (int expn)
{ // throw를 통해 변수를 인자값으로 받고 매개변수의 자료형과,
// throw의 자료형이 같으면 해당 catch블록 ㄱㄱ
cout << "숫자 저리가셈." << endl;
}
catch (char expn)
{
cout << "문자열 저리가셈." << endl;
}
```
