셀맨의 일상 블로그

#include <iostream>

using namespace std;

class Stack{

private:

        int stk[5]; //크기 5짜리 스택

        int index;

public:

        Stack(int index=-1); //디폴트 매개변수 인덱스 = -1(empty)

        Stack& operator<<(int op); //푸시

        friend bool operator!(Stack op);

        void operator>>(int &op); //팝

};

Stack::Stack(int index){this->index=index;} //index 초기화

Stack& Stack::operator<<(int op){ //푸시 구현

        index++; //인덱스 증가

        stk[index]=op; //오퍼랜드를 해당 인덱스에 넣어줌

        return *this; //현재 객체의 참조 반환

}

bool operator!(Stack op){ //비어있는지 확인

        if(op.index==-1)

               return true; //비었으면 true 리턴

        else

               return false;

}

void Stack::operator>>(int &op){

        index--; //인덱스 감소

        op= stk[index+1]; //제일 위의 원소 pop

}

int main(void){

        Stack stack;

        stack<<3<<5<<10; //3,5,10 순서의 스택

        while(true){

               if(!stack) break;

               int x;

               stack>>x; //제일 위의 원소부터 나옴

               cout<<x<<" ";

        }

        cout << endl;

        return 0;

}

#include <iostream>

using namespace std;

class Statistics{

private:

        int size; //동적 배열의 사이즈

        int index; //마지막 원소의 인덱스

        int *p; //동적 배열을 가리킬 포인터

public:

        Statistics(int size=5,int index=-1); //기본 사이즈 5, 인덱스 -1(nothing)

        friend bool operator!(Statistics op);

        void operator>>(int &op);

        Statistics& operator<<(int op);

        void operator~();

};

Statistics::Statistics(int size,int index){

        this->size=size;

        this->index=index;

        p=new int[size]; //size 크기만큼의 int 동적 배열 할당

}

bool operator!(Statistics op){

        if(op.index==-1) //index가 -1이면 true 반환

               return true;

        else

               return false;

}

void Statistics::operator>>(int &op){ //평균구하는 함수

        int sum=0;

        for(int i=0;i<index+1;i++){sum+=p[i];} //실제 원소 개수는 index+1 (0부터시작하니까)

        op= sum/(index+1); //op에 평균값 넣어줌(참조라서 원본 바뀜)

}

Statistics& Statistics::operator<<(int op){

        index++; //인덱스 증가

        if(size<=index){ //인덱스를 하나키웠는데 size와 크기 같으면 배열 크기보다 원소가 많은 경우

               int *tmp=new int[size+5]; //하나씩 키우면 자주 없앴다 만들었다 해야하니 5개씩 늘린다.

               for(int i=0;i<size;i++){ //(size+5로 하면 p크기가 size라서 오류날 수 있음)

                       tmp[i]=p[i]; //p의 원소를 전부 tmp에 복사

               }

               delete []p; //p가 가리키는 동적배열 힙에 반환

               p=tmp; //tmp가 가리키는 배열을 p도 가리키게 함(어차피 tmp는 사라지므로 깊은 복사 필요 없음)

               size+=5; //size 5 추가

        }

        p[index]=op; //index에 오퍼랜드 대입

        return *this; //현재 객체의 참조 리턴(이름)

}

void Statistics::operator~(){ //전부 출력하는 함수

        for(int i=0;i<index+1;i++){ //원소 개수 = index+1

               cout<<p[i]<<" ";

        }

        cout<<endl;

}

int main(void){

        Statistics stat;

        if(!stat) cout<<"현재 통계 데이타가 없습니다."<<endl;

        int x[5];

        cout <<"5 개의 정수를 입력하라>>";

        for(int i=0;i<5;i++) cin >> x[i]; //x[i]에 정수 입력

        for(int i=0;i<5;i++) stat << x[i]; //x[i] 값을 통계 객체에 삽입한다.

        stat << 100 << 200; //100, 200을 통계 객체에 삽입한다.

        ~stat; //통계 데이타를 모두 출력한다.

        int avg;

        stat>>avg; //통계 객체로부터 평균을 받는다.

        cout<<"avg="<<avg<<endl; //평균을 출력한다.

        return 0;

}

#include <iostream>

using namespace std;

class Circle{

private:

        int radius;

public:

        Circle(int radius=0){this->radius=radius;}

        void show(){cout<<"radius = "<<radius<<"인 원"<<endl;}

        friend Circle operator++(Circle &c);

        friend Circle operator++(Circle &c,int a);

        friend Circle operator+(int a,Circle c);

};

Circle operator++(Circle &c){ //전위 증가

        c.radius++;

        return c;

}

Circle operator++(Circle &c,int a){ //후위 증가

        Circle tmp=c;

        c.radius++;

        return tmp;

}

Circle operator+(int a,Circle c){ // 정수+객체 오퍼레이터

        Circle tmp;

        tmp.radius=a+c.radius;

        return tmp;

}

int main(void){

        Circle a(5), b(4);

        b=1+a;

        a.show();

        b.show();

        return 0;

}

#include <iostream>

using namespace std;

class Circle{

private:

        int radius;

public:

        Circle(int radius=0){this->radius=radius;}

        void show(){cout<<"radius = "<<radius<<"인 원"<<endl;}

        friend Circle operator++(Circle &c);

        friend Circle operator++(Circle &c,int a);

};

Circle operator++(Circle &c){ //전위 증가

        c.radius++;

        return c;

}

Circle operator++(Circle &c,int a){ //후위 증가

        Circle tmp=c;

        c.radius++;

        return tmp;

}

int main(void){

        Circle a(5), b(4);

        ++a; //증가 후 리턴

        b=a++; //대입 후 증가

        a.show();

        b.show();

        return 0;

}

#include <iostream>

using namespace std;

class Matrix{

private:

        int mat[4]; //인트형 배열 크기는 4

public:

        Matrix(int x0=0,int x1=0,int x2=0,int x3=0); //각 디폴트 매개변수는 0

        void show();

        void operator>>(int *x);

        void operator<<(int *y);

};

Matrix::Matrix(int x0,int x1, int x2, int x3){

        mat[0]=x0;     mat[1]=x1; //멤버 인트 배열을 매개변수로 차례로 초기화

        mat[2]=x2;     mat[3]=x3;

}

void Matrix::show(){ //출력함수

        cout<<"Matrix = {";

        for(int i=0;i<4;i++) {cout<<" "<<mat[i];}

        cout<<" }"<<endl;

}

void Matrix::operator>>(int *x){ //x가 가리키는 배열에 객체 내 배열 원소 차례로 대입

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

               x[i]=(this->mat)[i];

        }

}

void Matrix::operator<<(int *y){ //객체 내 배열에 y가 가리키는 배열 원소 차례로 대입

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

               (this->mat)[i]=y[i];

        }

}

int main(void){

        Matrix a(4,3,2,1), b;

        int x[4], y[4]={1,2,3,4}; //2차원 행렬의 4개 원소 값

        a>>x; //a의 각 원소를 배열 x에 복사, x[]는 {4,3,2,1}

        b<<y; // 배열 y의 원소 값을 b의 각 원소에 설정

        for(int i=0;i<4;i++) cout<<x[i]<<" "; //x[]출력

        cout<<endl;

        b.show();

        return 0;

}

#include <iostream>

using namespace std;

class Matrix{

private:

        int mat[4]; //인트형 배열 크기는 4

public:

        Matrix(int x0=0,int x1=0,int x2=0,int x3=0); //각 디폴트 매개변수는 0

        void show();

        friend void operator>>(Matrix op1,int *op2);

        friend void operator<<(Matrix &op1,int *op2);

};

Matrix::Matrix(int x0,int x1, int x2, int x3){

        mat[0]=x0;     mat[1]=x1; //멤버 인트 배열을 매개변수로 차례로 초기화

        mat[2]=x2;     mat[3]=x3;

}

void Matrix::show(){ //출력함수

        cout<<"Matrix = {";

        for(int i=0;i<4;i++) {cout<<" "<<mat[i];}

        cout<<" }"<<endl;

}

void operator>>(Matrix op1,int *op2){ //객체의 값을 배열에 대입

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

               op2[i]=(op1.mat)[i];

        }

}

void operator<<(Matrix &op1,int *op2){ //배열의 값을 객체에 대입

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

               (op1.mat)[i]=op2[i];

        }

}

int main(void){

        Matrix a(4,3,2,1), b;

        int x[4], y[4]={1,2,3,4}; //2차원 행렬의 4개 원소 값

        a>>x; //a의 각 원소를 배열 x에 복사, x[]는 {4,3,2,1}

        b<<y; // 배열 y의 원소 값을 b의 각 원소에 설정

        for(int i=0;i<4;i++) cout<<x[i]<<" "; //x[]출력

        cout<<endl;

        b.show();

        return 0;

}

#include <iostream>

using namespace std;

class Matrix{

private:

        int mat[4]; //인트형 어레이 mat 크기 4

public:

        Matrix(int x0=0,int x1=0,int x2=0, int x3=0);//각 디폴트 매개변수는 0

        void show();

        Matrix operator+(Matrix op);

        Matrix operator+=(Matrix op);

        bool operator==(Matrix op);

};

Matrix::Matrix(int x0,int x1,int x2, int x3){ //생성자, 매개변수를 각 원소에 대입

        mat[0]=x0;     mat[1]=x1;

        mat[2]=x2;     mat[3]=x3;

}

void Matrix::show(){ //출력함수

        cout<<"Matrix = {";

        for(int i=0;i<4;i++) {cout<<" "<<mat[i];}

        cout<<" }"<<endl;

}

Matrix Matrix::operator+(Matrix op){ //+연산자 오버로딩, 각원소를 전부 더해서 그 객체 리턴

        Matrix tmp;

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

               (tmp.mat)[i]=(this->mat)[i]+(op.mat)[i];

        }

        return tmp;

}

Matrix Matrix::operator+=(Matrix op){ //+=연산자 오버로딩 객체자신과 op의 원소를 각각더해서

        for(int i=0;i<4;i++){                 //자기 자신에 대입하고 객체자신 리턴

               (this->mat)[i]=(this->mat)[i]+(op.mat)[i];

        }

        return *this;

}

bool Matrix::operator==(Matrix op){ //==오퍼레이터 오버로딩

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

               if((this->mat)[i]!=(op.mat)[i]) return false; //같은 인덱스 원소 비교해서 다르면 바로 false 리턴

        }

        return true; //다맞으면 true 리턴

}

int main(void){

        Matrix a(1,2,3,4), b(2,3,4,5), c;

        c=a+b; //a+b값을 c에 대입

        a+=b; //a+b값을 a에 대입

        a.show(); b.show(); c.show();

        if(a==c) //a랑c가 같으면..

               cout<<"a and c are the same" <<endl;

        return 0;

}

#include <iostream>

using namespace std;

class Matrix{

private:

        int mat[4]; //인트형 어레이 mat 크기 4

public:

        Matrix(int x0=0,int x1=0,int x2=0, int x3=0);//각 디폴트 매개변수는 0

        void show();

        friend Matrix operator+(Matrix op1,Matrix op2);

        friend Matrix operator+=(Matrix &op1,Matrix op2);

        friend bool operator==(Matrix op1,Matrix op2);

};

Matrix::Matrix(int x0,int x1,int x2, int x3){ //생성자, 매개변수를 각 원소에 대입

        mat[0]=x0;     mat[1]=x1;

        mat[2]=x2;     mat[3]=x3;

}

void Matrix::show(){ //출력함수

        cout<<"Matrix = {";

        for(int i=0;i<4;i++) {cout<<" "<<mat[i];}

        cout<<" }"<<endl;

}

Matrix operator+(Matrix op1,Matrix op2){  //각 원소를 더해 나온 행렬을 리턴

        Matrix tmp;

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

               (tmp.mat)[i]=(op1.mat)[i]+(op2.mat)[i];

        }

        return tmp;

}

Matrix operator+=(Matrix &op1,Matrix op2){ //레퍼런스op1을 쓰는 이유는 op1도 바뀌어야해서

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

               (op1.mat)[i]=(op1.mat)[i]+(op2.mat)[i]; //배열의 같은 인덱스 값을 더해서 op1의 인덱스원소에 대입

        }

        return op1;

}

bool operator==(Matrix op1,Matrix op2){

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

               if((op1.mat)[i]!=(op2.mat)[i]) return false; //같은 인덱스 원소 비교해서 다르면 바로 false 리턴

        }

        return true; //다맞으면 true 리턴

}

int main(void){

        Matrix a(1,2,3,4), b(2,3,4,5), c;

        c=a+b; //a+b값을 c에 대입

        a+=b; //a+b값을 a에 대입

        a.show(); b.show(); c.show();

        if(a==c) //a랑c가 같으면..

               cout<<"a and c are the same" <<endl;

        return 0;

}

#include <iostream>

using namespace std;

class MyVector{

private:

        int* mem;

        int size;

public:

        MyVector(int n,int val);

        ~MyVector(){delete []mem;} //동적 배열이 할당받은 메모리를 힙에 반환

        void printVector();

};

MyVector::MyVector(int n=100,int val=0){

        //n실인자가 입력되지 않으면 100대입,val 실인자 없으면 0대입

        mem=new int[n]; //n크기의 인트형 동적 배열

        size=n;

        for(int i=0;i<size;i++)

               mem[i]=val; //동적 배열의 모든 원소를 val로 초기화해준다.

}

void MyVector::printVector(){ //10개씩 끊어서 출력

        int moc=size/10; //몫

        int namuji=size%10; //나머지

        for(int j=0;j<moc;j++){

        for(int i=0;i<10;i++){cout<<mem[i];} //몫에 해당하는만큼 출력

        cout<<endl;

        }

        for(int k=0;k<namuji;k++) //나머지에 해당하는 만큼 출력

               {cout<<mem[k];}

        cout<<endl;

}

int main(void){

        MyVector m1; //사이즈 100, 원소는 0

        MyVector m2(53); //사이즈 53, 원소는 0

        MyVector m3(27,3); //사이즈 27, 원소는 3

        m1.printVector();

        m2.printVector();

        m3.printVector();

        return 0;

}

#include <iostream>

#include <string>

using namespace std;

class Person{

private:

        int id;

        double weight;

        string name;

public:

        void show(){cout<<id<<" "<<weight<<" "<<name<<endl;} //출력함수

        Person();

        Person(int id, string name);

        Person(int id,string name,double weight); //생성자 오버로딩

};

Person::Person(){//매개변수 없는 생성자

        this->id=1;

        this->weight=20.5;

        this->name="Grace";

}

Person::Person(int id, string name){ //매개변수 2개인 생성자

        this->id=id;

        this->weight=20.5;

        this->name=name;

}

Person::Person(int id,string name,double weight){ //매개변수 3개인 생성자

        this->id=id;

        this->name=name;

        this->weight=weight;

}

int main(void){

        Person grace, ashley(2, "Ashley"), helen(3, "Helen", 32.5);

        grace.show();

        ashley.show();

        helen.show();

        return 0;

}

#include <iostream>

#include <string>

using namespace std;

class Person{

private:

        int id;

        double weight;

        string name;

public:

        void show(){cout<<id<<" "<<weight<<" "<<name<<endl;} //출력함수

        Person(int id,string name,double weight);

};

Person::Person(int id=1,string name="Grace",double weight=20.5){ //디폴트매개변수를 가진 생성자

        this->id=id;

        this->name=name;

        this->weight=weight;

        //id에 입력이 없으면 1 대입, name에 입력이 없으면 "Grace" 대입, weight에 입력이 없으면 20.5 대입

}

int main(void){

        Person grace, ashley(2, "Ashley"), helen(3, "Helen", 32.5);

        grace.show();

        ashley.show();

        helen.show();

        return 0;

}

- int 타입의 x1, y1, x2, y2 필드 : 사각형을 구성하는 두 점의 좌표

- 생성자 2개 : 매개 변수 없는 생성자와 x1, y1, x2, y2의 값을 설정하는 생성자

- void set(int x1, int y1, iny x2, int y2) : x1, y1, x2, y2좌표 설정

- int square() : 사각형 넓이 리턴

- void show() :좌표와 넓이 등 직사각형 정보의 화면 출력

예) 사각형의 좌표는 (0,0), (0,0)입니다.

- boolean equals(Rectangle r) : 인자로 전달된 객체 r과 현 객체가 동일한 직사각형이면 true 리턴

Rectangle을 이용한 main() 메소드는 다음과 같으며 이 main() 메소드가 잘 작동하도록 하라.

public class RectManager {

             public static void main(String args[]) {

                           Rectangle r = new Rectangle();

                           Rectangle s = new Rectangle(1,1,2,3);

                           r.show();

                           s.show();

                           System.out.println(s.square());

                           r.set(-2,2,-1,4);

                           r.show();

                           System.out.println(r.square());

                          if(r.equals(s))

                                        System.out.println("두 사각형은 같습니다.");

             }

}