1、C01:看上去好坑的運算子過載

總時間限制: 1000ms 記憶體限制: 65536kB
描述
程式填空

#include <iostream> 
using namespace std;
class MyInt 
{ 
    int nVal; 
    public: 
    MyInt( int n) { nVal = n ;}
// 在此處補充你的程式碼
    MyInt& operator-(int n)
    {
        nVal -= n;
        return *this;
    }
    operator int()
    {
        return
 
 nVal;
    }
// end of my code
}; 
int Inc(int n) {
    return n + 1;
}
int main () { 
    //分析main函式的執行過程：
    //1.int型為引數的有參建構函式，已實現
    //2.過載以int為引數的"-"運算子,由於修改了nVal，所以返回值是自身，返回值型別為類引用
    //3.Inc的引數為int，而objInt為類物件，需要過載型別轉換運算子
    int n;
    while(cin >>n) {
        MyInt objInt(n); 
        objInt-2
 
-1-3; 
        cout << Inc(objInt);
        cout <<","; 
        objInt-2-1; 
        cout << Inc(objInt) << endl;
    }
    return 0;
}

輸入
多組資料，每組一行，整數n
輸出
對每組資料，輸出一行，包括兩個整數， n-5和n - 8
樣例輸入
20
30
樣例輸出
15,12
25,22
來源
Guo Wei

2、C02:驚呆！Point竟然能這樣輸入輸出

總時間限制: 1000ms 記憶體限制: 65536kB
描述
程式填空

#include <iostream> 
using namespace std;
class Point { 
    private: 
        int x; 
        int y; 
    public: 
        Point() { };
// 在此處補充你的程式碼
    friend istream & operator>>(istream & is, Point &rhs)
    {
        is >> rhs.x >> rhs.y;
        return is;
    }
    friend ostream & operator<<(ostream & os, const Point &rhs)
    {
        os << rhs.x << "," << rhs.y;
        return os;
    }
// end of my code
}; 
int main() 
{ 
    //分析main函式的執行過程：
    //1.無參建構函式，已實現
    //2.過載引數為類物件的>>運算子
    //3.過載引數為類物件的<<運算子
    //Note：istream和ostream類的物件，建構函式均為private，不能自定義流物件
    //運算子<<和運算子>>的過載一律宣告為友元函式，引數型別和返回值的型別均為流物件的引用
    Point p;
    while(cin >> p) {
        cout << p << endl;
     }
    return 0;
}

輸入
多組資料，每組兩個整數
輸出
對每組資料，輸出一行，就是輸入的兩個整數
樣例輸入
2 3
4 5
樣例輸出
2,3
4,5
來源
Guo Wei

3、C03:第四周程式填空題3

總時間限制: 1000ms 記憶體限制: 65536kB
描述
寫一個二維陣列類 Array2,使得下面程式的輸出結果是：

0,1,2,3,

4,5,6,7,

8,9,10,11,

next

0,1,2,3,

4,5,6,7,

8,9,10,11,

程式：

#include <iostream>
#include <cstring>
using namespace std;

class Array2 {
// 在此處補充你的程式碼
private:
    int row;
    int col;
    int size_;
    int *pInt;
public:
    Array2(int r = 0, int c = 0) :row(r), col(c), size_(r*c) 
    { 
        if (size_ == 0)
            pInt = nullptr;
        else
            pInt = new int[size_]; 
    }
    Array2 & operator=(const Array2 & rhs)
    {
        if (this == &rhs)
            return *this;
        row = rhs.row;
        col = rhs.col;
        size_ = rhs.size_;
        if (size_ == 0)
            pInt = nullptr;
        else
        {
            pInt = new int[size_];
            memcpy(pInt, rhs.pInt, size_ * sizeof(int));
        }       
        return *this;
    }
    int * operator[](int n)
    {
        return pInt + n * col;
    }
    int operator()(int i, int j)
    {
        return *(pInt + i * col + j);
    }
// end of my code
};

int main() {
    //分析main函式的執行過程：
    //1.引數為兩個int型的有參建構函式，指明瞭row和col
    //開闢了一塊記憶體空間，有成員int* ptr，用size記錄需要申請空間的大小
    //2.a[i][j]可以作為左值被賦值，類過載了運算子[]，返回int*，
    //第二個[]是內部型別的解析，不用理會
    //3.a(i,j)得到了a[i][j]，類過載了引數為兩個int型的運算子()，返回值為int
    //4.Array2 b，需要無參建構函式，需要初始化各個成員變數，可以併到有參建構函式     
    //5.b = a，需要過載賦值運算子函式
    Array2 a(3,4);
    int i,j;
    for(  i = 0;i < 3; ++i )
        for(  j = 0; j < 4; j ++ )
            a[i][j] = i * 4 + j;
    for(  i = 0;i < 3; ++i ) {
        for(  j = 0; j < 4; j ++ ) {
            cout << a(i,j) << ",";
        }
        cout << endl;
    }
    cout << "next" << endl;
    Array2 b;     b = a;
    for(  i = 0;i < 3; ++i ) {
        for(  j = 0; j < 4; j ++ ) {
            cout << b[i][j] << ",";
        }
        cout << endl;
    }
    return 0;
}

4、C04:別叫，這個大整數已經很簡化了!

總時間限制: 1000ms 記憶體限制: 65536kB
描述
程式填空，輸出指定結果

#include <iostream> 
#include <cstring> 
#include <cstdlib> 
#include <cstdio> 
using namespace std;
const int MAX = 110; 
class CHugeInt {
// 在此處補充你的程式碼
//核心功能為+運算，需要低位對齊，帶進位地向高位計算，int與char * 均按每一位的值逆序儲存
//儲存運算元的位數，在輸出的時候需要用到
//s最多為200位，如果按實際位數分配，那麼在實際的+操作時，可能需要比較運算元的位數...等額外的判別
//所以一律固定申請的位數為200+，用length代表實際位數，用空間換取一些邏輯上的簡化
//Note：空間大小固定，逆序儲存，儲存位數
private:
    int *ptr;
    int length;
public:
    CHugeInt(const char *pstr)
    {
        length = strlen(pstr);
        ptr = new int[210];
        memset(ptr, 0, 210 * sizeof(int));
        for (int i = 0; i < length; ++i)
            *(ptr + i) = *(pstr + length - 1 - i) - '0';
    }
    CHugeInt(int n)
    {
        ptr = new int[210];
        memset(ptr, 0, 210 * sizeof(int));
        int i = 0;
        while (n)
        {
            *(ptr + i) = n % 10;
            n /= 10;
            ++i;
        }
        length = i;
    }
    CHugeInt(const CHugeInt & rhs) //copy constructor
    {
        length = rhs.length;
        ptr = new int[210];
        memset(ptr, 0, 210 * sizeof(int));
        memcpy(ptr, rhs.ptr,210*sizeof(int));
    }
    //為了支援+=，++這種改變了自身狀態的操作，需要過載賦值運算子
    //由於涉及pointer，淺複製會double free，需要自定義深複製的操作
    CHugeInt & operator=(const CHugeInt & rhs)
    {
        if (this == &rhs)
            return *this;
        length = rhs.length;
        memcpy(ptr, rhs.ptr, 210 * sizeof(int));
        return *this;
    }
    CHugeInt & operator +=(const int &n)
    {
        //思路是委託函式CHugeInt operator+(const CHugeInt & x, const int & y)執行
        //再委託operator+(const CHugeInt & x, const CHugeInt & y)執行
        return *this = *this + n;
    }
    //核心功能bolck，由於3個加法函式又是過載關係，又是委託關係，都設定為友元函式
    friend CHugeInt operator+(const CHugeInt & x, const CHugeInt & y)
    {
        CHugeInt temp(0);//operarator + 返回一個CHugeInt類的物件
        //temp作為儲存和的物件，兩個運算元非負，其長度至少為兩個加數中較大的那個
        //加法執行完畢之後可能還需依進位增加其長度
        temp.length = x.length > y.length ? x.length : y.length;
        //這裡體現出申請的是int型空間的優越性，一輪完成加法，暫不處理進位
        //若是申請的char型的空間，想要表示10到18這9個溢位的加法標誌就有些折騰了
        //用空間換邏輯性
        for (int i = 0; i < temp.length; ++i)
            *(temp.ptr + i) = *(x.ptr + i) + *(y.ptr + i);
        for (int i = 0; i < temp.length; ++i)
        {
            if (*(temp.ptr + i)>=10)
            {
                *(temp.ptr + i) -= 10;
                *(temp.ptr + i + 1) += 1;
            }               
        }
        //最高位有進位，更新加法結果的位數
        if (*(temp.ptr + temp.length) == 1)
            ++temp.length;
        //return call copy constructor
        return temp;
    }
    //下面的兩個形式，核心思路都是用引數構造臨時物件，委託核心模組完成功能
    friend CHugeInt operator+(const int & x, const CHugeInt & y)
    {
        CHugeInt temp(x);
        return temp + y;
    }
    friend CHugeInt operator+(const CHugeInt & x, const int & y)
    {
        CHugeInt temp(y);
        return x + temp;
    }
    //下面的兩個形式，核心思路都是通過構造臨時物件，委託核心模組完成功能
    //不同點在於：後置++，返回+完成之後的物件
    //前置++，以示區別，過載形式多了個int型的引數，返回+完成之前的物件
    CHugeInt operator++()
    {
        return *this = *this + CHugeInt(1);
    }
    CHugeInt operator++(int)
    {
        CHugeInt temp(*this);
        *this = temp + CHugeInt(1);
        return temp;
    }
    //過載<<運算子，因為按位逆序儲存，輸出時從有效儲存空間的尾部一直輸出到起始位置
    friend ostream & operator<<(ostream & os, const CHugeInt & rhs)
    {
        for (int i = rhs.length - 1; i >= 0; --i)
            cout << *(rhs.ptr + i);
        return os;
    }
    ~CHugeInt()
    {
        delete []ptr;
    }
// end of my code
};
int  main() 
{ 
    //分析main函式的執行過程：
    // 1.CHugeInt a(s)，CHugeInt b(n)說明需要引數型別為int和char*的建構函式
    // 2.根據3個加法表示式，需要過載+運算子，有3種不同形式的過載形式,為了委託都設定為友元函式
    //    2.1 a + b 需要過載引數為分別為CHugeInt型，CHugeInt型
    //    2.2 n + a 需要過載引數為分別為int型，CHugeInt型，委託2.1中的函式執行
    //    2.3 a + n 需要過載引數為分別為CHugeInt型，int型的運算子+，委託2.1中的函式執行
    // 3. 需要過載+=運算子，同樣可以複用+運算子
    // 4. 需要過載兩種形式的++運算子
    // 5. 需要過載引數為CHugeInt型的<<運算子
    // EX:根據運算型別，需要複製建構函式，過載賦值運算子
    char s[210];
    int n;

    while (cin >> s >> n) {
        CHugeInt a(s);
        CHugeInt b(n);

        cout << a + b << endl;
        cout << n + a << endl;
        cout << a + n << endl;
        b += n;
        cout  << ++ b << endl;
        cout << b++ << endl;
        cout << b << endl;
    }
    return 0;
}

輸入
多組資料，每組資料是兩個非負整數s和 n。s最多可能200位， n用int能表示
輸出
對每組資料，輸出6行，內容分別是：
樣例輸入
99999999999999999999999999888888888888888812345678901234567789 12
6 6
樣例輸出
99999999999999999999999999888888888888888812345678901234567801
99999999999999999999999999888888888888888812345678901234567801
99999999999999999999999999888888888888888812345678901234567801
25
25
26
12
12
12
13
13
14
來源
Guo Wei