π§ Study/C++ & C#
04. μ°μ°μ μ€λ²λ‘λ© / μ΄λ μμ±μ&μ΄λ λμ μ°μ°μ / λμ λ©λͺ¨λ¦¬
GAMEMING
2024. 3. 27. 21:00
< μ°μ°μ μ€λ²λ‘λ© >
#include <iostream>
#include "save.h"
using namespace std;
// μλμ mainμ΄ λμκ°λλ‘ μ½λ©ν΄λ³΄μ
class Person {
private:
int age;
public:
Person(int age) : age(age)
{
cout << "Person::Person(age) μμ±μ μλ£" << endl;
}
Person()
{
cout << "Person::Person() μμ±μ μλ£" << endl;
}
~Person() // μλ©Έμ
{
cout << "Person::~Person μλ©Έμ μλ£" << endl;
}
void introduce();
Person add(const Person& p);
Person sub(const Person& p);
Person mul(const Person& p);
Person div(const Person& p);
};
int main()
{
Person player(30);
Person enemy(15);
player.introduce();
enemy.introduce();
Person addPlayer = player.add(enemy);
addPlayer.introduce();
Person subPlayer = player.sub(enemy);
subPlayer.introduce();
Person mulPlayer = player.mul(enemy);
mulPlayer.introduce();
Person divPlayer = player.div(enemy);
divPlayer.introduce();
}
void Person::introduce()
{
cout << "λμ΄ : " << age << endl;
}
Person Person::add(const Person& p)
{
Person m(this->age + p.age);
return m;
}
Person Person::sub(const Person& p)
{
Person m(this->age - p.age);
return m;
}
Person Person::mul(const Person& p)
{
Person m(this->age * p.age);
return m;
}
Person Person::div(const Person& p)
{
Person m(this->age / p.age);
return m;
}
// mainν¨μμ .add μν μ +κ° ν μ μμκΉ? => .operator+
// μ»΄νμΌλ¬ -> +λ₯Ό λ§λλ©΄ operator+() λ©€λ² ν¨μλ₯Ό μ°Ύκ³
// μ΄μ λ©€λ²ν¨μ μΌμͺ½κ³Ό μ€λ₯Έμͺ½μ μ΄ν΄λ³΄κ³ μννλ€.
// λ€μμΌλ‘ λ°κΏ μ μλ€.
class Person {
private:
int age;
public:
Person(int age) : age(age)
{
cout << "Person::Person(age) μμ±μ μλ£" << endl;
}
Person()
{
cout << "Person::Person() μμ±μ μλ£" << endl;
}
~Person() // μλ©Έμ
{
cout << "Person::~Person μλ©Έμ μλ£" << endl;
}
void introduce();
Person operator+(const Person& p);
Person operator-(const Person& p);
Person operator*(const Person& p);
Person operator/(const Person& p);
};
int main()
{
Person player(30);
Person enemy(15);
player.introduce();
enemy.introduce();
Person addPlayer = player + enemy; // + 3 μ νλ©΄ ? => νλ³νμ ν΅ν΄ κ°μ²΄κ° νλ λ λ§λ€μ΄μ Έ κ·Έλλ‘ μνλ¨
addPlayer.introduce();
Person subPlayer = player - enemy;
subPlayer.introduce();
Person mulPlayer = player * enemy;
mulPlayer.introduce();
Person divPlayer = player / enemy;
divPlayer.introduce();
}
void Person::introduce()
{
cout << "λμ΄ : " << age << endl;
}
Person Person::operator+(const Person& p)
{
Person m(this->age + p.age);
return m;
}
Person Person::operator-(const Person& p)
{
Person m(this->age - p.age);
return m;
}
Person Person::operator*(const Person& p)
{
Person m(this->age * p.age);
return m;
}
Person Person::operator/(const Person& p)
{
Person m(this->age / p.age);
return m;
}
// mainν¨μ
Person addPlayer = 3 + enemy; // μ μλ κΉ?
// + μ°μ°μλ₯Ό λ³΄κ³ operator μ°μ°μλ₯Ό μ°Ύλλ°
// 3 + λ₯Ό λ΄μλ μ΄λ€ ν΄λμ€μΈμ§ μ μ μμ
// ν΄λμ€ λ΄λΆ ν¨μλ‘λ§ μ μνλ κ²μ΄ μλ μΌλ° μ μ ν¨μλ‘ μ μ κ°λ₯νλ€.
// Person class λ΄λΆ
friend Person operator+(const Person& p, const Person& pp);
// μ μλΆλΆ
Person operator+(const Person& p, const Person& pp)
{
Person m(p.age + pp.age);
return m;
}
// μ€λ²λ‘λ© λν κ°λ₯νλ€
// * friend
// μμ μ κ°μ²΄λΏλ§μ΄ μλ λ€λ₯Έ νμ
μ κ°μ²΄λ₯Ό μ κ·Ό κ°λ₯
// νλμ ν΄λμ€μμ λ€λ₯Έ ν΄λμ€μ λ΄λΆ λ°μ΄ν°μ μ κ·Ό ν΄μΌν κ²½μ°
// ν¨μλ ν΄λμ€ μ μΈ μμ μ μΈν μ μκ³ μ κ·Ό μ μ΄ μ§μμ μν₯μ λ°μ§ X
// 볡μ¬μμ±μμ μ§μΈ 볡μ¬λμ
μ°μ°μ
// 볡μ¬μμ±μ -> κ°μ²΄λ₯Ό κ°μ νμ(ν΄λμ€)μ κ°μ²΄λ‘ μ΄κΈ°νν λ νΈμΆλλ ν¨μ
// λ³΅μ¬ λμ
μ°μ° -> κ°μ νμμ κ°μ²΄λΌλ¦¬ 볡μ¬νλ μ©λ
// λ³΅μ¬ λμ
μ°μ°μ
Person& operator=(const Person& p);
int main()
{
Person player(30);
Person enemy(15);
Person addPlayer = enemy; // opeartor=() μνλλ°λ μλμκ° -> μ?
addPlayer.introduce();
}
Person& Person::operator=(const Person& p)
{
this->age = p.age;
return *this;
}
< μ΄λμμ±μ & μ΄λ λμ μ°μ°μ >
int main()
{
Person player(30);
Person enemy(15);
Person copyPlayer(enemy);
Person movePlayer(std::move(player));
// λμκ°κΈ΄ νλλ°
// κΈ°μ‘΄ objμ μ΄μ©ν΄ μλ‘μ΄ κ²μ λ§λ€ λ
// copyκ° μλλΌ moveν΄μ κ°μ Έμ¬ μ μλ€
}
// ν΄λμ€ λ΄λΆ
// μ΄λμμ±μ
Person(Person&& other) noexcept : age(other.age)
{
// μμ 볡μ¬
other.age = 0;
cout << "Person::Person() μ΄λμμ±μ μλ£" << endl;
}
// μ΄λ λμ
μ°μ°μ
Person& operator=(Person&& other) noexcept;
Person& Person::operator=(Person&& other) noexcept
{
this->age = other.age;
other.age = 0;
return *this;
}
// nocxcept : μμΈλ₯Ό λμ§ κ°λ₯μ± μμμ μλ¦Ό (falseμΌ κ²½μ° μλ€λ κ²)
< λμ ν λΉ & λμ λ°°μ΄ >
// ν΄λμ€ λ΄λΆ
int setAge(int age) { return this->age = age; }
int main()
{
Person* player = new Person(320); // new -> μμ±μ
player->introduce();
int n;
cin >> n;
Person* mon = new Person[n];
for (int i = 0; i < n; i++) {
mon[n].setAge(i + 1);
mon[n].introduce();
}
delete player; // delete -> μλ©Έμ
delete[] mon;
}
< STRINGμ class >
class STRING {
private:
size_t num{}; //8
char* p{}; //8
public:
STRING();
~STRING();
STRING(const char* s);
// 볡μ¬μμ±μ(μ€νμ
ν¨μ)
STRING(const STRING& other);
STRING& operator=(const STRING& other);
// μ΄λμμ±μμ μ΄λν λΉμ°μ°μ ( && - r-value reference, μ΄λ(move)κ³Ό μλ²½μ λ¬(perfect forwarding)μ μ¬μ©)
STRING(STRING&& other);
// μ°μ°μ μ€λ²λ‘λ©
STRING operator+(const char*) const;
STRING operator+(const STRING&) const;
// μ
μΆλ ₯κΈ°λ₯μ μ΄ ν΄λμ€μ λ°μ ν κΈ°λ₯μ΄λ€.
// κ·Έλμ operator<< ν¨μλ STRINGμ λ©€λ²μ μμ§ μ΄ ν¨μλ λ©€λ²ν¨μμΈ κ² μ²λΌ μμ λ‘κ²
// μ κ·Όνλλ‘ μ½λ©νλ κ²μ΄ ν©λ¦¬μ μ΄λ€. -> μ΄ ν¨μλ₯Ό friendλ‘ μ μΈνλ€.
friend std::ostream& operator<<(std::ostream&, const STRING&);
};
STRING::STRING()
{
}
STRING::~STRING()
{
delete[]p;
}
STRING::STRING(const char* s) : num{ strlen(s) }
{
p = new char[num];
memcpy(p, s, num);
}
// 볡μ¬μμ±μ(μ€νμ
ν¨μ)
STRING::STRING(const STRING& other) : num(other.num)
{
p = new char[num];
// deep copy
memcpy(p, other.p, num); // DMA;
}
STRING& STRING::operator=(const STRING& other)
{
// λλ₯Ό λλ‘ ν λΉν μ΄μ κ° μλ€
if (this == &other) // thisλ μ£ΌμκΈ°μ otherλ μ£Όμ
return *this;
num = other.num;
delete[] p;
p = new char[num];
memcpy(p, other.p, num);
return *this;
}
// μ΄λμμ±μμ μ΄λν λΉμ°μ°μ ( && - r-value reference, μ΄λ(move)κ³Ό μλ²½μ λ¬(perfect forwarding)μ μ¬μ©)
STRING::STRING(STRING&& other) : num{ other.num }
{
// otherμ μμμ κ°μ Έμ¨λ€
p = other.p;
// otherλ₯Ό μ΄κΈ°ν
other.num = 0;
other.p = nullptr;
}
STRING STRING::operator + (const char* str) const {
STRING temp; // default ctor μ€νμ
ν¨μ
temp.num = num + strlen(str);
temp.p = new char(temp.num);
memcpy(temp.p, p, num);
memcpy(temp.p + num, str, strlen(str));
return temp; // μ¬κΈ°μ 볡μ¬μμ±μκ° νΈμΆλμ΄μΌ νμ§λ§ RVOκ° μλλλ€
// RVO(Return Value Optimization) - λ°νκ° μ΅μ ν
}
STRING STRING::operator+(const STRING& other) const {
STRING temp;
temp.num = num + other.num;
temp.p = new char[temp.num];
memcpy(temp.p, p, num);
memcpy(temp.p + num, other.p, other.num);
return temp;
}
std::ostream& operator<<(std::ostream& os, const STRING& s)
{
for (int i = 0; i < s.num; ++i)
os << s.p[i];
return os;
}
728x90