210914

//////////////////////////////#include <iostream>

//////////////////////////////

//////////////////////////////using namespace std;

//////////////////////////////

//////////////////////////////int main()

//////////////////////////////{

////////////////////////////// cout << "Hello world!" << endl;

////////////////////////////// return 0;

//////////////////////////////}

////////////////////////////

////////////////////////////#include <iostream>

////////////////////////////using namespace std;

////////////////////////////class RECT;

////////////////////////////bool equals(RECT r,RECT s);

////////////////////////////class RECT{

////////////////////////////int width, height;

////////////////////////////public:

//////////////////////////// RECT(int width,int height)

//////////////////////////// {

//////////////////////////// this-> width =width;

//////////////////////////// this-> height = height;

//////////////////////////// }

//////////////////////////// friend bool equals(RECT r,RECT s);

////////////////////////////};

////////////////////////////bool equals(RECT r,RECT s)

////////////////////////////{

//////////////////////////// if(r.width==s.width&&r.height==s.height)

//////////////////////////// {

//////////////////////////// return true;

//////////////////////////// }

//////////////////////////// else return false;

////////////////////////////}

////////////////////////////int main()

////////////////////////////{

//////////////////////////// RECT a(3,4),b(4,5);

//////////////////////////// if(equals(a,b)) cout << "equal" << endl;

//////////////////////////// else cout << "not equal" << endl;

////////////////////////////}

//////////////////////////

//////////////////////////

//////////////////////////#include <iostream>

//////////////////////////using namespace std;

//////////////////////////class RECT;

//////////////////////////class RECTM

//////////////////////////{

//////////////////////////public:

////////////////////////// bool equals(RECT r,RECT s);

//////////////////////////};

//////////////////////////class RECT{

//////////////////////////int width, height;

//////////////////////////public:

////////////////////////// RECT(int width,int height) { this->width=width; this->height=height;}

////////////////////////// friend bool RECTM::equals(RECT r,RECT s);

//////////////////////////};

//////////////////////////bool RECTM::equals(RECT r,RECT s)

//////////////////////////{

////////////////////////// if(r.width==s.width&&r.height==s.height)

////////////////////////// {

////////////////////////// return true;

////////////////////////// }

////////////////////////// else return false;

//////////////////////////}

//////////////////////////int main()

//////////////////////////{

////////////////////////// RECT a(3,4), b(3,4);

////////////////////////// RECTM man;

//////////////////////////

////////////////////////// if(man.equals(a,b)) cout << "equal" << endl;

////////////////////////// else cout << "not equal" << endl;

//////////////////////////}

////////////////////////

////////////////////////

////////////////////////#include <iostream>

////////////////////////using namespace std;

////////////////////////class RECT;

////////////////////////class RECTM{

////////////////////////public:

//////////////////////// bool equals(RECT r,RECT s);

//////////////////////// void copy(RECT& dest,RECT& src);

////////////////////////};

////////////////////////class RECT{

////////////////////////int width,height;

////////////////////////public:

//////////////////////// RECT(int width,int height) { this->width=width; this->height=height;}

//////////////////////// friend RECTM;

////////////////////////};

////////////////////////bool RECTM::equals(RECT r,RECT s)

////////////////////////{

//////////////////////// if(r.width==s.width&&r.height==s.height)

//////////////////////// {

//////////////////////// return true;

//////////////////////// }

//////////////////////// else return false;

////////////////////////

////////////////////////}

////////////////////////void RECTM::copy(RECT& dest,RECT& src)

////////////////////////{

//////////////////////// dest.width = src.width; dest.height = src.height;

////////////////////////}

////////////////////////int main()

////////////////////////{

//////////////////////// RECT a(3,4),b(3,4);

//////////////////////// RECTM man;

//////////////////////// man.copy(b,a);

//////////////////////// if(man.equals(a,b)) cout << "equal" << endl;

//////////////////////// else cout << "not equal" << endl;

////////////////////////}

////////////////////////

//////////////////////

//////////////////////#include <iostream>

//////////////////////using namespace std;

//////////////////////class Power{

//////////////////////int kick;

//////////////////////int punch;

//////////////////////public:

////////////////////// Power(int kick=0,int punch=0) { this-> kick=kick; this->punch=punch;}

////////////////////// void show();

////////////////////// Power operator+ (Power op2);

//////////////////////

//////////////////////};

//////////////////////void Power::show()

//////////////////////{

////////////////////// cout << "kick= " << kick << ',' << "punch= " << punch << endl;

//////////////////////}

//////////////////////Power Power::operator+(Power op2)

//////////////////////{

////////////////////// Power tmp;

////////////////////// tmp.kick = this->kick+op2.kick;

////////////////////// tmp.punch = this->punch+op2.punch;

////////////////////// return tmp;

//////////////////////}

//////////////////////int main()

//////////////////////{

////////////////////// Power a(3,5),b(4,6),c;

////////////////////// c = a+b;

////////////////////// a.show();

////////////////////// b.show();

////////////////////// c.show();

//////////////////////}

////////////////////

////////////////////#include <iostream>

////////////////////using namespace std;

////////////////////class Power{

////////////////////int kick;

////////////////////int punch;

////////////////////public:

//////////////////// Power(int kick=0,int punch=0) { this->kick=kick; this->punch=punch;}

//////////////////// void show();

//////////////////// bool operator== (Power op2);

////////////////////};

////////////////////void Power::show()

////////////////////{

//////////////////// cout << "kick= " << kick << ',' << "punch= " << punch << endl;

////////////////////}

////////////////////bool Power::operator==(Power op2)

////////////////////{

//////////////////// if(kick==op2.kick&&punch==op2.punch) return true;

//////////////////// else return false;

////////////////////}

////////////////////int main()

////////////////////{

//////////////////// Power a(3,5),b(3,5);

//////////////////// a.show();

//////////////////// b.show();

//////////////////// if(a == b) cout << "파워가 같다 " << endl;

//////////////////// else cout << "파워가 다르다 " << endl;

////////////////////}

////////////////////

//////////////////#include <iostream>

//////////////////using namespace std;

//////////////////class Power{

//////////////////int kick;

//////////////////int punch;

//////////////////public:

////////////////// Power(int kick=0,int punch=0) { this->kick=kick; this->punch=punch; }

////////////////// void show();

////////////////// Power& operator+= (Power op2);

//////////////////};

//////////////////void Power::show()

//////////////////{

////////////////// cout << "kick= " <<kick << ',' << "punch= " << punch << endl;

//////////////////}

//////////////////Power& Power::operator+=(Power op2)

//////////////////{

////////////////// kick= kick + op2.kick;

////////////////// punch = punch +op2.punch;

////////////////// return *this;

//////////////////}

//////////////////int main()

//////////////////{

////////////////// Power a(3,5),b(4,6),c;

////////////////// a.show();

////////////////// b.show();

////////////////// c=a+=b;

////////////////// a.show();

////////////////// c.show();

//////////////////}

////////////////

////////////////

//////////////////#include <iostream>

//////////////////using namespace std;

//////////////////class Power{

//////////////////int kick;

//////////////////int punch;

//////////////////public:

////////////////// Power(int kick=0,int punch=0) { this-> kick=kick; this->punch=punch; }

////////////////// void show();

////////////////// Power operator+ (int op2);

//////////////////};

//////////////////void Power::show()

//////////////////{

////////////////// cout << "kick= " << kick << ',' << "punch= " << punch << endl;

//////////////////}

//////////////////Power Power::operator+(int op2)

//////////////////{

////////////////// Power tmp;

////////////////// tmp.kick = kick+op2;

////////////////// tmp.punch = punch+op2;

////////////////// return tmp;

//////////////////}

//////////////////int main()

//////////////////{

////////////////// Power a(3,5),b;

////////////////// a.show();

////////////////// b.show();

////////////////// b= a+2;

////////////////// a.show();

////////////////// b.show();

//////////////////}

////////////////

////////////////

////////////////#include <iostream>

////////////////using namespace std;

////////////////class Power{

////////////////int kick;

////////////////int punch;

////////////////public:

//////////////// Power(int kick=0,int punch=0) { this->kick=kick; this->punch=punch; }

//////////////// void show();

//////////////// Power& operator++ ();

////////////////};

////////////////void Power::show()

////////////////{

//////////////// cout << "kick= " << kick << ',' << "punch= " << punch << endl;

////////////////}

////////////////Power& Power::operator++()

////////////////{

//////////////// kick++;

//////////////// punch++;

//////////////// return *this;

////////////////}

////////////////int main()

////////////////{

//////////////// Power a(3,5),b;

//////////////// a.show();

//////////////// b.show();

//////////////// b = ++a;

//////////////// a.show();

//////////////// b.show();

////////////////}

////////////////

////////////////

//////////////

//////////////#include <iostream>

//////////////using namespace std;

//////////////class Power{

//////////////int kick;

//////////////int punch;

//////////////public:

////////////// Power(int kick=0,int punch=0) { this->kick=kick; this->punch=punch; }

////////////// void show();

////////////// bool operator! ();

//////////////};

//////////////void Power::show()

//////////////{

////////////// cout << "kick= " << kick << ',' << "punch= " << punch << endl;

//////////////}

//////////////bool Power::operator!()

//////////////{

////////////// if(kick==0&&punch==0) return true;

////////////// else return false;

//////////////}

//////////////int main()

//////////////{

////////////// Power a(0,0),b(5,5);

////////////// if(!a) cout << "a의 파워는 0" << endl;

////////////// else cout << "a의 파워는 0이 아님 " << endl;

////////////// if(!b) cout << "b의 파워는 0" << endl;

////////////// else cout << "b의 파워는 0이 아님 " << endl;

//////////////}

////////////

////////////#include <iostream>

////////////using namespace std;

////////////class Power{

//////////// int kick;

//////////// int punch;

////////////public:

//////////// Power(int kick=0,int punch=0) { this->kick=kick; this->punch=punch;}

//////////// void show();

//////////// Power operator++ (int x);

////////////};

////////////void Power::show()

////////////{

//////////// cout << "kick= " << kick << ',' << "punch= " << punch << endl;

////////////}

////////////Power Power::operator++(int x)

////////////{

//////////// Power tmp = *this;

//////////// kick++;

//////////// punch++;

//////////// return tmp;

////////////}

////////////int main()

////////////{

//////////// Power a(3,5),b;

//////////// a.show();

//////////// b.show();

//////////// b = a++;

//////////// a.show();

//////////// b.show();

////////////}

//////////

//////////#include<iostream>

//////////

//////////class Power {

////////// int a, b;

//////////public:

////////// Power(int x=0, int y=0) {

////////// a = x;

////////// b = y;

////////// }

////////// friend int operator+(Power a, Power b);

//////////};

//////////

//////////int operator+(Power a, Power b) {

////////// return a*b;

//////////}

//////////

//////////int main() {

////////// Power a(10, 20), b(5, 15), c;

//////////

//////////}

////////

////////#include <iostream>

////////using namespace std;

////////class Power{

////////int kick;

////////int punch;

////////public:

//////// Power(int kick=0,int punch=0) { this->kick=kick; this->punch=punch; }

//////// void show();

//////// friend Power operator+ (int op1,Power op2);

////////};

////////void Power::show()

////////{

//////// cout << "kick= " << kick << ',' << "punch= " << punch << endl;

////////}

////////Power operator+(int op1,Power op2)

////////{

//////// Power tmp;

//////// tmp.kick=op1+op2.kick;

//////// tmp.punch=op1+op2.punch;

//////// return tmp;

////////}

////////int main()

////////{

//////// Power a(3,5),b;

//////// a.show();

//////// b.show();

//////// b = 2+a;

//////// a.show();

//////// b.show();

////////}

//////

//////

//////#include <iostream>

//////using namespace std;

//////class Power{

//////int kick;

//////int punch;

//////public:

////// Power(int kick=0, int punch=0) { this->kick=kick; this->punch=punch; }

////// void show();

////// friend Power operator+(Power op1,Power op2);

//////};

//////void Power::show()

//////{

////// cout << "kick= " << kick << ',' << "punch= " << punch << endl;

//////}

//////Power operator+(Power op1,Power op2)

//////{

////// Power tmp;

////// tmp.kick =op1.kick+op2.kick;

////// tmp.punch = op1.punch+op2.punch;

////// return tmp;

//////}

//////int main()

//////{

////// Power a(3,5),b(4,6),c;

////// c = a+b;

////// a.show();

////// b.show();

////// c.show();

//////}

////

////#include <iostream>

////using namespace std;

////class Power{

////int kick;

////int punch;

////public:

//// Power(int kick=0,int punch=0) { this->kick= kick; this->punch=punch; }

//// void show();

//// friend Power& operator++(Power& op);

//// friend Power operator++(Power& op,int x);

////};

////void Power::show()

////{

//// cout << "kick= " << kick << ',' << "punch= " << punch << endl;

////}

////Power& operator++(Power& op)

////{

//// op.kick++;

//// op.punch++;

//// return op;

////}

////Power operator++(Power& op,int x)

////{

//// Power tmp= op;

//// op.kick++;

//// op.punch++;

//// return tmp;

////}

////int main()

////{

//// Power a(3,5),b;

//// b= ++a;

//// a.show();

//// b.show();

////

//// b= a++;

//// a.show();

//// b.show();

////

////}

//

//#include <iostream>

//using namespace std;

//class Power{

//int kick;

//int punch;

//public:

// Power(int kick=0,int punch=0) { this->kick=kick; this->punch=punch; }

// void show();

// Power& operator << (int n);

//};

//void Power::show()

//{

// cout <<"kick= " << kick << ',' << "punch= " << punch << endl;

//}

//Power& Power::operator<<(int n)

//{

// kick += n;

// punch += n;

// return *this;

//}

//int main()

//{

// int m;

//

// Power a(1,2);

// for(int i=0;i<3;i++)

// {

// cin >> m;

// a << m;

// }

//

// a.show();

//}

#include <iostream>

using namespace std;

class Book{

string title;

int price,pages;

public:

book(string title="",int price=0, int pages=0) {this->title=title; this->pages=pages; this->price=price; }

void show() { cout << title << ' ' << price << "원 " << pages << "페이지 " << endl; }

string getTitle() { return title; }

};

int main()

{

Book a("명품 C++",30000,500),b("고품 C++",30000,500);

if(a==30000) cout <<

}