zoukankan      html  css  js  c++  java
  • 面向对象程序设计-C++ Operator Overloading & Type conversion (Static)【第十一次上课笔记】

    本次上课继续讲解了 [ ] 、-> 等运算符重载的具体例子

    也讲解了C++单个参数的类的类型转换的案例

    最后稍微提到了 static 的第三种作用:静态数据成员

    具体详解我都已注释出来了,大家可以慢慢看

    有任何问题都可以在这篇文章下留言我会及时解答 :)


    #include <iostream>
    #include <cmath>
    
    using namespace std;
    
    class myArray {
    private:
        float * p;
        unsigned int size;
    public:
        myArray (unsigned int len = 0);
        ~myArray ();
        unsigned int getSize () const;
        double moudar () const;
    
        const float & operator [] (int index) const; //下标运算符只能被重载在成员函数中
        float & operator [] (int index);             //Only member function
    };
    
    myArray::myArray (unsigned int len) {
        float * tmp = new float[len];
        if (NULL == tmp) {       //Check whether new work OK
            cout << "memory allocation error!" << endl;
            p = NULL;
            size = 0;
        } else {
            p = tmp;
            size = len;
            for (int i = 0; i < len; ++i) {
                p[i] = 0.0f;
            }
        }
    }
    
    myArray::~myArray () {
        if (NULL != p)  {
            delete [] p;
            size = 0;
        }
        p = NULL;               //保证析构后 p 指针为空
    }
    
    unsigned int myArray::getSize () const {
        return size;
    }
    
    double myArray::moudar () const {
        //float sum = 0.0f;
        double sum = 0.0;
        for (int i = 0; i < size; ++i) {
            float a = p[i];
            sum += a * a;
        }
        sum = sqrt (sum);
        return sum;
    }
    
    const float & myArray::operator [] (int index) const {
        return p[index];
    }
    
    float & myArray::operator [] (int index) {
        return p[index];
    }
    
    ostream & operator << (ostream & out, const myArray & ma) {
        int size = ma.getSize ();
        out << "{";
        for (int i = 0; i < size - 1; ++i) {
            out << ma[i] << ", ";
        }
        out << ma[size - 1] << "}" << endl;
        return out;
    }
    
    int main() {
    
        myArray ma(4);           //init one object
        double length = ma.moudar ();
    
        float element = ma[2];    //Get the element
        ma[3] = 12.5f;            //Update the element value
        ma[0] = 3.8f;
    
        cout << ma << endl;       //!! Only golbal function
    
        return 0;
    }

    // =  ()  []  ->  ->*   Only overloaded by member function
    
    // << 在表达输出的时候,只能重载为全局函数;表达移位运算的时候,都可以
    
    #include <iostream>
    
    using namespace std;
    
    class myClassA {
    public:
        int i;
        myClassA (int k = 200) : i(k) { cout << "myClassA init" << endl; };
    };
    
    class myClassB {               //类B负责对其子对象创建,如果什么都不写,就是用默认
                                   //构造函数创建,否则,需要在成员初始化列表写
    public:
        int m;
        myClassA a;                //对象成员,创建B对象的时候,会先对A对象构造
        myClassA * operator -> ();
        //myClassB * operator -> ();
    
        myClassB (int j) : a(j), m(10) { cout << "myClassB init" << endl; };
    };
    
    /*
    myClassB * myClassB::operator->() {
        cout << "myClassB * myClassB::operator->() " << endl;
        return this;
    }
    */
    
    myClassA * myClassB::operator->() {
        cout << " myClassA * myClassB::operator->() " << endl;
        return &a;
    }
    
    int main() {
    
        myClassB b (23);
        cout << b->i << endl;
        //cout << b->m << endl;
    
        return 0;
    }

    //C++单个参数的类的类型转换
    //类的转化
    
    #include <iostream>
    
    using namespace std;
    
    //class A;
    
    class Integer {
        int i;
        //A a;
    public:
        //explicit 的作用 : 告诉编译器,如果要转化,一定是显式
        
        explicit Integer (int k = 0) : i (k) { cout << "Integer (int k = 0)" << endl; }
        Integer & operator = (const Integer & obj);
        friend ostream & operator << (ostream & out, const Integer & ing);
    
        //operator A() { return a; }
        explicit operator int () { return i; }   //类型转换函数
        explicit operator double () { return i + 45.51; }   //类型转换函数
    };
    
    ostream & operator << (ostream & out, const Integer & ing) {
        out << ing.i << endl;
    
        return out;
    }
    
    Integer & Integer::operator = (const Integer & obj) {
        if (this == &obj)    return *this;   //检查自赋值
        i = obj.i;
        cout << "operator = (const Integer & obj) " << endl;
        return *this;
    }
    
    int main () {
    
        Integer a (45), b;
        b = Integer (63);
        cout << b << endl;
    
        int m = int (b);          //将Integer 类型转换成整形
        cout << m << endl;
    
        double d = double (b);
        cout << d << endl;
    
        return 0;
    }

    //static 静态数据成员
    
    #include <iostream>
    
    using namespace std;
    
    class Integer {
        //static int i;
        static int number;  //整个类只有一个版本,所有对象共享
    public:
        Integer (int k = 0) { ++number; }
        static int getNumber () const { return number; }
    };
    
    int Integer::number = 0;
    
    int main () {
    
        Integer Zhao, jin, wei, shi, tian, cai;
    
        cout << Zhao.getNumber () << endl;
        cout << Integer::getNumber()<< endl;
    
        return 0;
    }
  • 相关阅读:
    CSS浮动(float、clear)通俗讲解
    JAVA 类的加载
    数据库操作 delete和truncate的区别
    正则表达式 匹配相同数字
    Oracle EBS OM 取消订单
    Oracle EBS OM 取消订单行
    Oracle EBS OM 已存在的OM订单增加物料
    Oracle EBS OM 创建订单
    Oracle EBS INV 创建物料搬运单头
    Oracle EBS INV 创建物料搬运单
  • 原文地址:https://www.cnblogs.com/wushuaiyi/p/4494396.html
Copyright © 2011-2022 走看看