C++学习笔记06

面向对象的扩展功能

　　　　备注：编译器在编译一个类时，会先扫描类定义（不含函数体），之后才扫描类实现（各个成员函数的函数体，静态成员变量的初始化），所以在类的成员函数里可以访问在后面才出现的成员。

　　　　const对象调用的成员函数也要求不会修改成员变量的数据。成员函数可以在参数表后用const来宣称自己不会修改当前对象的数据，称为const成员函数。因此，用const对象只能调用const成员函数。

　　　　const对象内部如果确实有需要修改的数据成员，用Mutable来修饰即可。

#include<iostream>
#include<ctime>
#include<cstdlib>
using namespace std;
typedef int T;

class A{//数组类,封装和增强数组的功能
    T* a;
    int len;

public:
    A(int n,T init = T()):a(new T[n]),len(n),cur(0){ //零初始化
        for (int i = 0;i<n;i++) 
            a[i] = init;
    }
    ~A(){
        delete[] a; a =NULL;
    }
    int set(int idx,int val){
        a[idx] = val;
    }
    int get(int idx){
        return a[idx];
    }
    void randfill(){
        srand(time(NULL));
        for(int i = 0;i<len;i++)
            a[i] = rand()%100;
    }
     int size()const{//参数表之后用const来宣称自己不会修改当前对象的数据
        return len;
    }
    int next()const{
        return a[cur++%len];
    }
    mutable int cur; //const对象内部允许修改的成员
    void use(const A& x) //const对象调用的成员函数也要求不会修改成员变量的数据
    {
        cout << x.size()<<endl;
        for(int i=0;i<3;i++) cout<< x.next()<<" ";
        cout << endl;    
    }
};
int main()
{
    A x(10);
    x.randfill();
    for (int i = 0;i<x.size();i++)
        cout<<x.get(i)<<" ";
    cout<<endl;
    x.use(x);
    system("pause");
    return 0;
}

　　运算符重载

　　　　　　在C++中，运算符都被当成函数。C++允许程序员自己来规定运算符如何工作，方法就是自己定义相应的运算符函数。

　　　　　　格式：operatior+运算符 e.g. operatior&,operatior+,operatior++.....，称为运算符重载。运算符函数代替运算符，其中函数参数对应运算符的操作数，函数返回值对应运算符的运算结果。

　　　　　　运算符函数的形参合返回类型尽量用引用，尽量加const。运算符函数的定义格式之一：全局函数

　　　　　　返回类型 operator运算符（参数表）

　　　　　　双目：运算结果的类型 operator运算符（操作数1，操作数2）

　　　　　　单目：运算结果的类型 operator运算符（操作数）

　　　　在全局函数中如果需要访问对象的非公开成员，需要在类中对这个全局函数进行授权，方法是在类中用friend声明这个函数声明为友元。友元不是成员，一般在类里声明在外面定义，也可以在类里面friend声明的地方直接定义，但它依旧是友元，不是成员。

　　　　如果需要的话，一个类A也可以把另外一个类B声明为友元，这等同于把B类的所有成员函数都声明为A类的友元　　

　

#include<iostream>
using namespace std;

class R{
    int n;//分子
    int d;//分母
public:
    //友元声明，向这个函数授权允许其访问本类成员
    friend ostream& operator<<(ostream& o,const R& x);
    friend istream& operator>>(istream& i,R& x);
    friend R& operator+(const R& x,const R& y);

    R(int cn,int cd =1):n(cn),d(cd)
    {
        if(d<0) n=-n,d=-d;
        if(d==0) d=1;
        for(int i=d;i>1;i--)
        {
            if(d%i==0&&n%i==0)
            {
                d/=i,n/=i;
                break;
            }
        }
    }
};

    ostream& operator<<(ostream& o,const R& x) //重载运算符 << 
    {
        o<<x.n<<"/"<<x.d<<endl;
        return o;
    }
    istream& operator>>(istream& i,R& x)//x不要加const,用来输入要改变x的值
    {
        char c;
        i>>x.n>>c>>x.d;//用户输入3/5，其中"/"要丢弃
        x =R (x.n,x.d);//匿名对象
        return i;
    }
    R& operator+(const R& x,const R& y)
    {
        int nn = x.n*y.d+y.n*x.d;
        int dd = x.d*y.d;
        return R(nn,dd);
    }


int main()
{
    R a(6,8),b(8,-12);
    cout<<a; //==>operator<<(cout,a) 双目：运算结果的类型 operator运算符（操作数1，操作数2）
    cout<<a<<b;//==>operator(operator<<(cout,a),b)
    R x(6,8),y(6,8);
    cin>>x>>y;
    cout<<x<<y;
    cout<<x+y; //operator+(x,y),x.poerator+(y) 三种写法效果一样
    system("pause");
    return 0;
}