C++/기초를 탄탄히 세워주는 C++ 프로그래밍 입문(황준하 저)

기초를 탄탄히 세워주는 C++ 프로그래밍 입문 7장 연습문제

꾸준함. 2017. 7. 3. 17:21

[7.1]

/*

예제 7.1에서 CPoint 클래스에 덧셈뿐만 아니라 뺄셈(Sub), 부호반대(Invert), 이동(Move),

1씩 증가(Inc)를 위한 멤버 함수들을 추가해본다.

main 함수와 실행 결과를 참고한다

*/

#include <iostream>

using namespace std;

 

class CPoint

{

private:

        int x;

        int y;

public:

        CPoint(int a = 0, int b = 0) :x(a), y(b)

        {

        }

        CPoint Sum(const CPoint &Po)

        {

               return CPoint(x + Po.x, y + Po.y);

        }

        CPoint Sub(const CPoint &Po)

        {

               return CPoint(x - Po.x, y - Po.y);

        }

        CPoint Invert()

        {

               return CPoint(-x, -y);

        }

        CPoint Move(int a, int b)

        {

               return CPoint(x + a, y + b);

        }

        CPoint Inc()

        {

               return CPoint(x + 1, y + 1);

        }

        void Print()

        {

               cout << "(" << x << ", " << y << ")" << endl;

        }

};

 

int main(void)

{

        CPoint P1(1, 1);

        CPoint P2(2, 2);

        CPoint P3 = P1.Sum(P2);

        CPoint P4 = P1.Sub(P2);

        CPoint P5 = P1.Invert();

        CPoint P6 = P1.Inc();

 

        P1.Print();

        P2.Print();

        P3.Print();

        P4.Print();

        P5.Print();

        P6.Print();

 

        return 0;

}

 


[7.2]

/*

시간을 나타내는 CTime 클래스를 만들어 본다.

CTime 클래스는 시(int Hour), (int Minute), (int Second)를 나타내는 멤버 변수를 포함하고 있다.

다음 main 함수와 실행 결과를 참고하여 두 객체 사이의 +연산이 가능하도록 만들어 본다.

한번은 멤버 함수에 의한 연산자 오버로딩을 사용하고, 한번은 전역 함수에 의한 연산자 오버로딩을 사용해 본다

*/

#include <iostream>

using namespace std;

 

class CTime

{

private:

        int Hour;

        int Minute;

        int Second;

public:

        CTime(int h, int m, int s) :Hour(h), Minute(m), Second(s)

        {

        }

        CTime operator+(const CTime &T)

        {

               int h = Hour+T.Hour, m = Minute+T.Minute, s = Second+T.Second;

               if (m > 60)

               {

                       m -= 60;

                       h++;

               }

               if (s > 60)

               {

                       s -= 60;

                       s++;

               }

               return CTime(h, m, s);

        }

        /*

        friend CTime operator+(const CTime &T1, const CTime &T2)

        {

        }

        */

        void Print()

        {

               cout << Hour << " " << Minute << " " << Second << "" << endl;

        }

};

 

/*

CTime operator+(const CTime &T1, const CTime &T2)

{

        int h = T1.Hour+T2.Hour, m = T1.Minute+T2.Minute, s = T1.Second+T2.Second;

        if (m > 60)

        {

               m -= 60;

               h++;

        }

        if (s > 60)

        {

               s -= 60;

               s++;

        }

        return CTime(h, m, s);

}

*/

int main(void)

{

        CTime time1(4, 50, 40);

        CTime time2(3, 40, 30);

        CTime time3 = time1 + time2;

 

        time1.Print();

        time2.Print();

        time3.Print();

 

        return 0;

}


[7.3]

/*

예제 7.5의 모든 연산자 오버로딩 함수들을 전역 함수로 구현해 본다

아마도 멤버 함수에 의한 연산자 오버로딩을 더 많이 사용하게 될 것이다.

그러나 부득이하게 전역 함수에 의한 연산자 오버로딩을 사용해야만 하는 경우가 있으며

바로 다음 절에서 접하게 될 것이다.

따라서 본 연습문제를 통해 전역함수에 의한 연산자 오버로딩에도 익숙해지도록한다

*/

#include <iostream>

using namespace std;

 

class CPoint

{

private:

        int x;

        int y;

public:

        CPoint(int a = 0, int b = 0) :x(a), y(b)

        {

        }

        friend CPoint operator+(const CPoint &P1, const CPoint &P2);

        friend CPoint operator+(const CPoint &P, int a);

        friend CPoint operator-(const CPoint &P1, const CPoint &P2);

        friend CPoint operator-(const CPoint &P, int a);

        friend CPoint operator*(const CPoint &P, int a);

        friend CPoint operator/(const CPoint &P, int a);

        void Print()

        {

               cout << "(" << x << ", " << y << ")" << endl;

        }

};

 

CPoint operator+(const CPoint &P1, const CPoint &P2)

{

        return CPoint(P1.x + P2.x, P1.y + P2.y);

}

 

CPoint operator+(const CPoint &P, int a)

{

        return CPoint(P.x + a, P.y + a);

}

 

CPoint operator-(const CPoint &P1, const CPoint &P2)

{

        return CPoint(P1.x - P2.x, P1.y - P2.y);

}

 

CPoint operator-(const CPoint &P, int a)

{

        return CPoint(P.x - a, P.y - a);

}

 

CPoint operator*(const CPoint &P, int a)

{

        return CPoint(P.x*a, P.y*a);

}

 

CPoint operator/(const CPoint &P, int a)

{

        return CPoint(P.x / a, P.y / a);

}

 

int main(void)

{

        CPoint P1(2, 2), P2(4, 4);

        int a = 2;

 

        (P1 + P2).Print();

        (P1 + a).Print();

        (P1 - P2).Print();

        (P1 - a).Print();

        (P1 * a).Print();

        (P1 / a).Print();

        return 0;

}

 


[7.4]

/*

복소수를 나타내는 CComplex 클래스를 만들어 본다.

복소수는 (a+bi)로 표현되며 a b는 각각 double로 표현된다고 가정하자.

이 때 다음과 같은 연산이 가능하도록 클래스를 만들어 본다.

복소수 A=(a+bi), B=(c+di), x는 실수로 가정한다

*/

#include <iostream>

using namespace std;

 

class CComplex

{

private:

        double a;

        double b;

public:

        CComplex(int i = 0, int j = 0) :a(i), b(j)

        {

        }

        CComplex(const CComplex &copy)

        {

               a = copy.a;

               b = copy.b;

        }

        CComplex operator+(const CComplex &Co)

        {

               return CComplex(a + Co.a, b + Co.b);

        }

        CComplex operator+(int x)

        {

               return CComplex(a + x, b);

        }

        CComplex operator-(const CComplex &Co)

        {

               return CComplex(a - Co.a, b - Co.b);

        }

        CComplex operator-(int x)

        {

               return CComplex(a - x, b);

        }

 

        void Print()

        {

               cout << a << " + " << b << "i" << endl;

        }

 

        friend CComplex operator+(int x, const CComplex &Co); //전역 함수

        friend CComplex operator-(int x, const CComplex &Co);

};

 

CComplex operator+(int x, const CComplex &Co)

{

        return CComplex(x + Co.a, Co.b);

}

 

CComplex operator-(int x, const CComplex &Co)

{

        return CComplex(x - Co.a, Co.b);

}

 

int main(void)

{

        CComplex C1(1, 2), C2(3, 4);

        double a = 2;

 

        CComplex C3 = C1 + C2;

        CComplex C4 = C1 - C2;

        CComplex C5 = C1 - a;

        CComplex C6 = a - C1;

 

        C3.Print();

        C4.Print();

        C5.Print();

        C6.Print();

        return 0;

}

 


[7.5]

/*

CArray 클래스가 있다.

클래스의 멤버 변수로는 5개의 원소를 갖는 배열이 포함되어 있따.

생성자를 통해 각 원소의 값을 0, 1, 2, 3, 4로 초기화한다.

그리고 + 부호 연산자 오버로딩과 - 부호 연산자 오버로딩을 구현한다.

+부호 연산자는 각 원소의 값을 오른쪽으로 1씩 이동시키는 것이며,

-부호 연산자는 각 원소의 값을 왼쪽으로 1씩 이동시키는 것이다.

, 부호 연산자를 연속으로 적용시킬 수 있도록 해야 한다.

물론 가장 오른쪽 또는 왼쪽 원소의 값은 반대쪽 끝 원소로 이동한다

*/

#include <iostream>

using namespace std;

 

class CArray

{

private:

        int arr[5];

public:

        CArray()

        {

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

               {

                       arr[i] = i;

               }

        }

        CArray &operator+()

        {

               int copy[5];

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

                       copy[i] = arr[i];

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

               {

                       if (i == 0)

                              arr[i] = copy[4];

                       else

                              arr[i] = copy[i - 1];

               }

               return *this;

        }

 

        CArray &operator-()

        {

               int copy[5];

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

                       copy[i] = arr[i];

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

               {

                       if (i != 4)

                              arr[i] = copy[i + 1];

                       else

                              arr[i] = copy[0];

               }

               return *this;

        }

 

        void Print()

        {

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

                       cout << arr[i] << " ";

               cout << endl;

        }

};

 

int main(void)

{

        CArray ary1;

        ary1.Print();

 

        CArray ary2 = +ary1;

        ary1.Print();

        ary2.Print();

        -(-ary1);

        ary1.Print();

 

        return 0;

}

 


[7.6]

/*

연습문제 7.5에서 +, - 부호 연산자 오버로딩을 전역 함수로 구현해 본다

이항 연산자를 전역 함수로 구현하는 경우 2개의 매개변수가 전달된다.

그렇다면 단항 연산에서는 1개의 매개변수가 전달될 것이다.

기본 원리는 이항 연산자 오버로딩과 동일하다

*/

#include <iostream>

using namespace std;

 

class CArray

{

private:

        int arr[5];

public:

        CArray()

        {

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

               {

                       arr[i] = i;

               }

        }

       

        void Print()

        {

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

                       cout << arr[i] << " ";

               cout << endl;

        }

 

        friend CArray &operator+(CArray &C);

        friend CArray &operator-(CArray &C);

};

 

CArray &operator+(CArray &C)

{

        CArray copy;

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

               copy.arr[i] = C.arr[i];

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

        {

               if (i == 0)

                       C.arr[i] = copy.arr[4];

               else

                       C.arr[i] = copy.arr[i - 1];

        }

        return C;

}

 

CArray &operator-(CArray &C)

{

        CArray copy;

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

               copy.arr[i] = C.arr[i];

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

        {

               if (i == 4)

                       C.arr[i] = copy.arr[0];

               else

                       C.arr[i] = copy.arr[i + 1];

        }

        return C;

}

 

 

int main(void)

{

        CArray ary1;

        ary1.Print();

 

        CArray ary2 = +ary1;

        ary1.Print();

        ary2.Print();

        -(-ary1);

        ary1.Print();

 

        return 0;

}

 


[7.7]

/*

CPoint 클래스가 (예제 7.9)와 예제 7.10에 구현된 전위 증가 연산자와 후위 증가 연산자를

모두 포함하도록 구현하고, 2가지 증가 연산자를 함께 테스틓해 볼 수 있도록 main 함수를 작성해본다

*/

#include <iostream>

using namespace std;

 

class CPoint

{

        int x;

        int y;

public:

        CPoint(int a = 0, int b = 0) :x(a), y(b)

        {

        }

        CPoint &operator++() //전위

        {

               x++;

               y++;

               return (*this);

        }

        CPoint &operator++(int NotUsed) //후위

        {

               CPoint temp = (*this);

               x++;

               y++;

               return temp;

        }

        void Print()

        {

               cout << "(" << x << ", " << y << ")" << endl;

        }

};

 

int main(void)

{

        CPoint P1(1, 1);

        CPoint P2 = (++P1)++;

        CPoint P3 = (P1++);

 

        P1.Print();

        P2.Print();

        P3.Print();

 

        return 0;

}


[7.8]

/*

CPoint 클래스에 전위 감소 연산자와 후위 감소 연산자를 추갛해 본다

*/

#include <iostream>

using namespace std;

 

class CPoint

{

        int x;

        int y;

public:

        CPoint(int a = 0, int b = 0) :x(a), y(b)

        {

        }

        CPoint &operator++() //전위 증가

        {

               x++;

               y++;

               return (*this);

        }

        CPoint &operator++(int NotUsed) //후위 증가

        {

               CPoint temp = (*this);

               x++;

               y++;

               return temp;

        }

        CPoint &operator--() //전위 감소

        {

               x--;

               y--;

               return (*this);

        }

        CPoint &operator--(int NotUsed) //후위 감소

        {

               CPoint temp = (*this);

               x--;

               y--;

               return temp;

        }

        void Print()

        {

               cout << "(" << x << ", " << y << ")" << endl;

        }

};

 

int main(void)

{

        CPoint P1(1, 1);

        CPoint P2 = (++P1)++;

        CPoint P3 = (P1++);

        CPoint P4 = --(P1);

        CPoint P5 = (--P1)--;

 

        P1.Print();

        P2.Print();

        P3.Print();

        P4.Print();

        P5.Print();

        P1.Print();

 

        return 0;

}


[7.9]

/*

예제 7.11에서 double형 변수와 char형 변수에 대한 출력 연산자 오버로딩 및 입력 연산자

오버로딩도 구현해보도록 한다.

또한 이를 테스트하기 위한 main 함수를 작성해본다.

*/

#include <cstdio>

using namespace std;

 

char *endl = "\n";

char *tab = "\t";

 

class ostream

{

public:

        ostream &operator<<(int val) //int 값에 대한 << 연산자 오버로딩

        {

               printf("%d", val);

               return (*this);

        }

        ostream &operator<<(char *str) //char * 값에 대한 <<연산자 오버로딩

        {

               printf("%s", str);

               return (*this);

        }

        ostream &operator<<(double val) //double 값에 대한 << 연산자 오버로딩

        {

               printf("%lf", val);

               return (*this);

        }

        ostream &operator<<(char c) //char 값에 대한 << 연산자 오버로딩

        {

               printf("%c", c);

               return (*this);

        }

};

 

class istream

{

public:

        istream &operator>>(int &val) //int 값에 대한 >> 연산자 오버로딩

        {

               scanf("%d", &val);

               return (*this);

        }

        istream &operator>>(char *str) //char *값에 대한 >> 연산자 오버로딩

        {

               scanf("%s", str);

               return (*this);

        }

        istream &operator>>(double &val) //double 값에 대한 >>연산자 오버로딩

        {

               scanf("%lf", &val);

               return (*this);

        }

        istream &operator>>(char &c) //char 값에 대한 >> 연산자 오버로딩

        {

               scanf("%c", &c);

               return (*this);

        }

};

 

ostream cout;

istream cin;

 

int main(void)

{

        double PI;

        char alpha;

        cout << "double , char 값 입력:";

        cin >> PI >> alpha;

 

        cout << PI << endl;

        cout << alpha << endl;

        return 0;

}


[7.10]

/*

연습문제 7.4에서 구현한 CComplex 클래스에 대해 Print 멤버 함수를 대체할 수 있도록

출력 연산자 오버로딩을 구현해 본다.

그리고 복소수의 값(실수 2)을 입력받을 수 있도록 입력 연산자 오버로딩을 구현하고

이를 테스트하기 위한 main 함수를 작성해 본다

*/

#include <iostream>

using namespace std;

 

class CComplex

{

private:

        double a;

        double b;

public:

        CComplex(int i = 0, int j = 0) :a(i), b(j)

        {

        }

        CComplex(const CComplex &copy)

        {

               a = copy.a;

               b = copy.b;

        }

        CComplex operator+(const CComplex &Co)

        {

               return CComplex(a + Co.a, b + Co.b);

        }

        CComplex operator+(int x)

        {

               return CComplex(a + x, b);

        }

        CComplex operator-(const CComplex &Co)

        {

               return CComplex(a - Co.a, b - Co.b);

        }

        CComplex operator-(int x)

        {

               return CComplex(a - x, b);

        }

        /*

        void Print()

        {

               cout << a << " + " << b << "i" << endl;

        }

        */

        friend CComplex operator+(int x, const CComplex &Co); //전역 함수

        friend CComplex operator-(int x, const CComplex &Co);

 

        friend ostream &operator<<(ostream &out, CComplex &Co);

        friend istream &operator>>(istream &in, CComplex &Co);

};

 

CComplex operator+(int x, const CComplex &Co)

{

        return CComplex(x + Co.a, Co.b);

}

 

CComplex operator-(int x, const CComplex &Co)

{

        return CComplex(x - Co.a, Co.b);

}

 

ostream &operator<<(ostream &out, CComplex &Co)

{

        out << Co.a << " + " << Co.b << "i" << endl;

        return out;

}

 

istream &operator>>(istream &in, CComplex &Co)

{

        cout << "복소수 입력: ";

        in >> Co.a >> Co.b;

        return in;

}

 

int main(void)

{

        CComplex C1(1, 2);

        cout << C1;

 

        cin >> C1;

        cout << C1;

 

        return 0;

}

 


[7.11]

/*

임의 길이의 int형 배열을 다룰 수 있는 CArray 클래스를 작성하여 본다.

멤버 변수로는 배열의 크기(int count), 배열 포인터(int *ary)를 가지고 있다.

객체 생성 시 각 원소의 값은 rand 함수를 사용하여 임의의 값(0~9)으로 채우도록 한다.

소멸자에서는 동적으로 생성한 메모리를 해제해야 한다.

main 함수와 같이 실행될 수 있도록 만들어 본다.

*/

#include <iostream>

#include <ctime>

#include <cstdlib>

using namespace std;

 

class CArray

{

private:

        int *ary;

        int count;

public:

        CArray(int num) :count(num)

        {

               ary = new int[count];

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

                       ary[i] = rand() % 10 + 1;

        }

        ~CArray()

        {

               delete[]ary;

        }

        CArray(const CArray &copy) //복사 생성자

        {

               count = copy.count;

               ary = new int[count];

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

                       ary[i] = copy.ary[i];

        }

        CArray &operator=(const CArray &copy)

        {

               delete[]ary;

               count = copy.count;

               ary = new int[count];

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

                       ary[i] = copy.ary[i];

               return (*this);

        }

        friend ostream &operator<<(ostream &out, const CArray Ao);

};

 

ostream &operator<<(ostream &out, const CArray Ao)

{

        for (int i = 0; i < Ao.count; i++)

               out << Ao.ary[i] << "\t";

        return out;

}

 

int main(void)

{

        srand((unsigned)time(NULL));

 

        CArray Ary1(3);

        CArray Ary2(5);

 

        cout << Ary1 << endl;

        cout << Ary2 << endl;

 

        Ary1 = Ary2;

 

        cout << Ary1 << endl;

        cout << Ary2 << endl;

        return 0;

}

 


[7.12]

/*

연습문제 7.11에서 작성한 CArray 클래스를 대상으로 다음 main 함수가 수행되는지 확인해본다.

수행되지 않는다면 그 원인을 설명하고 수행될 수 있도록 CArray 클래스를 수정해본다.

덧셈 연산은 2개의 배열을 연결하는 기능을 수행한다

*/

#include <iostream>

#include <ctime>

#include <cstdlib>

using namespace std;

 

class CArray

{

private:

        int *ary;

        int count;

public:

        CArray(int num) :count(num)

        {

               ary = new int[count];

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

                       ary[i] = rand() % 9 + 1;

        }

        ~CArray()

        {

               delete[]ary;

        }

        CArray(const CArray &copy) //복사 생성자

        {

               count = copy.count;

               ary = new int[count];

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

                       ary[i] = copy.ary[i];

        }

        CArray &operator=(const CArray &copy)

        {

               delete[]ary;

               count = copy.count;

               ary = new int[count];

               for (int i = 0; i < copy.count; i++)

                       ary[i] = copy.ary[i];

               return (*this);

        }

 

        friend ostream &operator<<(ostream &out, const CArray Ao);

        friend CArray operator+(const CArray &A1, const CArray &A2);

};

 

ostream &operator<<(ostream &out, const CArray Ao)

{

        for (int i = 0; i < Ao.count; i++)

               out << Ao.ary[i] << "\t";

        return out;

}

 

CArray operator+(const CArray &A1, const CArray &A2)

{

        CArray A3(A1.count+A2.count);

        int idx = 0;

 

        for (int i = 0; i < A1.count; i++)

               A3.ary[idx++] = A1.ary[i];

        for (int i = 0; i < A2.count; i++)

               A3.ary[idx++] = A2.ary[i];

        return A3;

}

 

int main(void)

{

        srand((unsigned)time(NULL));

 

        CArray Ary1(3);

        CArray Ary2(5);

        CArray Ary3(7);

 

        cout << Ary1 << endl;

        cout << Ary2 << endl;

        cout << Ary3 << endl;

 

        //cout << "오류 시작지점" << endl;

        Ary3 = Ary1 + Ary2; //덧셈 연산자 오버로딩 정의해야함

 

        cout << Ary1 << endl;

        cout << Ary2 << endl;

        cout << Ary3 << endl;

 

        return 0;

}


[7.13]

/*

연습문제 7.12에서 작성한 프로그램에서 다음과 같은 코드가 수행될 수 있도록

CArray 클래스를 수정해 본다.

CArray Ary1(5);

Ary1[0]=5;

Ary1[1]=7;

Ary1[5]=9; //범위를 벗어나므로 에러 메시지를 출력해야 함

*/

#include <iostream>

#include <ctime>

#include <cstdlib>

using namespace std;

 

class CArray

{

private:

        int *ary;

        int count;

public:

        CArray(int num) :count(num)

        {

               ary = new int[count];

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

                       ary[i] = rand() % 9 + 1;

        }

        ~CArray()

        {

               delete[]ary;

        }

        CArray(const CArray &copy) //복사 생성자

        {

               count = copy.count;

               ary = new int[count];

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

                       ary[i] = copy.ary[i];

        }

        CArray &operator=(const CArray &copy)

        {

               delete[]ary;

               count = copy.count;

               ary = new int[count];

               for (int i = 0; i < copy.count; i++)

                       ary[i] = copy.ary[i];

               return (*this);

        }

        int &operator[](int index)

        {

               if (index < count)

                       return ary[index];

               else

               {

                       cout << "범위 벗어남, 0번째 인덱스에 값을 대입" << endl;

                       return ary[0];

               }

        }

        friend ostream &operator<<(ostream &out, const CArray Ao);

        friend CArray operator+(const CArray &A1, const CArray &A2);

};

 

ostream &operator<<(ostream &out, const CArray Ao)

{

        for (int i = 0; i < Ao.count; i++)

               out << Ao.ary[i] << "\t";

        return out;

}

 

CArray operator+(const CArray &A1, const CArray &A2)

{

        CArray A3(A1.count + A2.count);

        int idx = 0;

 

        for (int i = 0; i < A1.count; i++)

               A3.ary[idx++] = A1.ary[i];

        for (int i = 0; i < A2.count; i++)

               A3.ary[idx++] = A2.ary[i];

        return A3;

}

 

int main(void)

{

        srand((unsigned)time(NULL));

 

        CArray Ary1(5);

        Ary1[0] = 5;

        Ary1[1] = 7;

        Ary1[5] = 9;

 

        cout << Ary1 << endl;

 

        return 0;

}


[7.14]

/*

연습문제 7.13에서 작성한 프로그램에서 다음 코드와 같이 배열 첨자 연산자 대신

함수 호출 연산자를 사용하여 배역의 각 원소에 접근할 수 있도록 CArray 클래스를 수정해 본다

CArray Ary(5);

Ary1(0)=5;

Ary2(1)=7;

Ary3(5)=9; //범위를 벗어나므로 에러 메시지를 출력함

*/

#include <iostream>

#include <ctime>

#include <cstdlib>

using namespace std;

 

class CArray

{

private:

        int *ary;

        int count;

public:

        CArray(int num) :count(num)

        {

               ary = new int[count];

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

                       ary[i] = rand() % 9 + 1;

        }

        ~CArray()

        {

               delete[]ary;

        }

        CArray(const CArray &copy) //복사 생성자

        {

               count = copy.count;

               ary = new int[count];

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

                       ary[i] = copy.ary[i];

        }

        CArray &operator=(const CArray &copy)

        {

               delete[]ary;

               count = copy.count;

               ary = new int[count];

               for (int i = 0; i < copy.count; i++)

                       ary[i] = copy.ary[i];

               return (*this);

        }

        int &operator[](int index)

        {

               if (index < count)

                       return ary[index];

               else

               {

                       cout << "범위 벗어남, 0번째 인덱스에 값을 대입" << endl;

                       return ary[0];

               }

        }

        int &operator()(int index)

        {

               if (index < count)

                       return ary[index];

               else

               {

                       cout << "범위 벗어남, 0번째 인덱스에 값을 대입" << endl;

                       return ary[0];

               }

        }

        friend ostream &operator<<(ostream &out, const CArray Ao);

        friend CArray operator+(const CArray &A1, const CArray &A2);

};

 

ostream &operator<<(ostream &out, const CArray Ao)

{

        for (int i = 0; i < Ao.count; i++)

               out << Ao.ary[i] << "\t";

        return out;

}

 

CArray operator+(const CArray &A1, const CArray &A2)

{

        CArray A3(A1.count + A2.count);

        int idx = 0;

 

        for (int i = 0; i < A1.count; i++)

               A3.ary[idx++] = A1.ary[i];

        for (int i = 0; i < A2.count; i++)

               A3.ary[idx++] = A2.ary[i];

        return A3;

}

 

int main(void)

{

        srand((unsigned)time(NULL));

 

        CArray Ary1(5);

        Ary1(0) = 5;

        Ary1(1) = 7;

        Ary1(5) = 9;

 

        cout << Ary1 << endl;

 

        return 0;

}


[7.15]

/*

다음과 같은 main 함수가 수행될 수 있도록 CString 클래스를 작성해본다

*/

#include <iostream>

#include <cstring>

using namespace std;

 

class CString

{

private:

        char *str;

public:

        CString(char *string = "Unknown")

        {

               int len = strlen(string);

               str = new char[len + 1];

               strcpy(str, string);

        }

        CString(const CString &copy) //복사 생성자

        {

               int len = strlen(copy.str);

               str = new char[len + 1];

               strcpy(str, copy.str);

        }

        ~CString()

        {

               delete[]str;

        }

        CString &operator=(const CString &copy)

        {

               delete[]str;

               str = new char[strlen(copy.str) + 1];

               strcpy(str, copy.str);

               return *this;

        }

        CString operator+(const CString &copy)

        {

               int len = strlen(str) + strlen(copy.str) + 1;

               char *string = new char[len];

 

               strcpy(string, str);

               strcat(string, copy.str);

 

               CString word(string);

               delete[]string;

 

               return word;

        }

        CString &operator+=(const CString &copy)

        {

               int len = strlen(str) + strlen(copy.str) + 1;

               char *string = new char[len];

 

               strcpy(string, str);

               delete[]str;

 

               strcat(string, copy.str);

               str = string;

 

               return *this;

        }

        bool operator==(const CString &copy)

        {

               return strcmp(str, copy.str);

        }

        friend ostream &operator<<(ostream &out, const CString &string);

        friend istream &operator>>(istream &in, CString &string);

};

 

ostream &operator<<(ostream &out, const CString &string)

{

        out << string.str << endl;

        return out;

}

 

istream &operator>>(istream &in, CString &string)

{

        char word[50];

        in >> word;

 

        string = CString(word);

 

        return in;

}

 

 

int main(void)

{

        CString str1 = "Good ";

        CString str2 = "morning";

        CString str3;

        str3 = str1 + str2;

 

        cout << str1 << endl;

        cout << str2 << endl;

        cout << str3 << endl;

 

        str1 += str2;

        if (str1 == str3)

        {

               cout << "equal!" << endl;

        }

        CString str4;

        cout << "문자열 입력: ";

        cin >> str4;

        cout << "입력한 문자열: " << str4 << endl;

        return 0;

}

 



개발 환경:Visual Studio 2017


지적, 조언, 질문 환영입니다! 댓글 남겨주세요~


[참고] 기초를 탄탄히 세워주는 C++ 프로그래밍 입문 황준하 저, http://kin.naver.com/qna/detail.nhn?d1id=1&dirId=1040101&docId=279765695&ref=me1lnk&scrollTo=answer1(직접 질문한 글)

반응형