美文网首页
c++操作符重载

c++操作符重载

作者: 第八区 | 来源:发表于2017-08-14 16:01 被阅读20次

定义

运算符重载的 实质 是 函数的重载

  • 使用意义
    • 赋予操作符更多的意义,同一个运算符,对不同类型的操作数,所发生的行为不同是
    • 程序更加简洁
  • 写法格式:返回值 operator运算符(参数列表){}
  • 重载的要求:
    • 1、内置类型的操作符不能被重载
    • 2、不能为内置类型定义其他的操作符
    • 3、操作符重载不能改变操作符的优先级
    • 4、操作数个数不能改变
  • 重载方式:
    • 1、类的成员方法
    • 2、类的有友元方法
    • 3、全局方法

注意:

  • ++a和a++的重载区别。a++的重载方法中多一个占位参数
  • 最好不好重载&&和||。因为无法实现短路功能。
  • =, ->, [], ()不可以是全局域中的重载
  • >><<的从在需要使用友元方法或重载方法。因为第一个操作类是ostream或istream。而我们无法在ostream和istream中定义重载方法,所以只能使用类的友元方法或全局方法来重载

示例

  • Array.h
//
// Created by eric on 2017/8/14.
//

#ifndef CHONGZAI_ARRAY_H
#define CHONGZAI_ARRAY_H

#include "iostream"

using namespace std;

class Array {
private:
    int mLength;
    int *data;

    friend Array operator+(Array &array1, Array &array2);

    friend ostream &operator<<(ostream &out, Array &array);

    friend istream &operator>>(istream &in, Array &array);

public:
    Array(int len = 0);

    Array(const Array &array);

    Array(const int *arr);

    void setData(int index, int data);

    int getData(int index);

    int &operator[](int index);

    void operator=(Array &array);

    Array &operator()(Array &array);

    void print();

    ~Array();

    int getMLength() const;

    void setMLength(int mLength);

    int *getData() const;

    void setData(int *data);

};


#endif //CHONGZAI_ARRAY_H
  • Array.cpp
//
// Created by eric on 2017/8/14.
//

#include "Array.h"
#include <iostream>

using namespace std;


Array::Array(const int *arr) {

}

void Array::setData(int index, int data) {
    this->data[index] = data;
}

int &Array::operator[](int index) {
    return data[index];
}

Array::Array(int len) {
    mLength = len;
    data = new int[mLength];
}

Array::Array(const Array &array) {
    cout << "copy construct func" << endl;
    if (mLength > 0 && data != NULL) {
        delete[]data;
    }
    mLength = array.getMLength();
    data = new int[mLength];
    for (int i = 0; i < mLength; i++) {
        data[i] = array.getData()[i];
    }
}

int Array::getMLength() const {
    return mLength;
}

void Array::setMLength(int mLength) {
    Array::mLength = mLength;
}

int *Array::getData() const {
    return data;
}

void Array::setData(int *data) {
    Array::data = data;
}

Array::~Array() {
    if (data != NULL) {
        delete[]data;
    }
}

void Array::operator=(Array &array) {
    cout << "operator=" << endl;
    if (mLength > 0 && data != NULL) {
        delete[]data;
    }
    mLength = array.getMLength();
    data = new int[mLength];
    for (int i = 0; i < mLength; i++) {
        data[i] = array.getData()[i];
    }
}

void Array::print() {
    for (int i = 0; i < mLength; i++) {
        cout << data[i] << " ";
    }
    cout << endl;
}

Array &Array::operator()(Array &array) {
    if (mLength >= array.getMLength()) {
        return *this;
    } else {
        return array;
    }
}

Array operator+(Array &array1, Array &array2) {
    cout << "operator+" << endl;
    int len = array1.mLength + array2.mLength;
    Array array(len);
    for (int i = 0; i < array1.mLength; i++) {
        array.setData(i, array1.getData(i));
    }
    for (int i = 0; i < array2.mLength; i++) {
        array.setData(array1.getMLength() + i, array2.getData(i));
    }
//    return array;
    array.print();
    array1.print();
    array2.print();
    return array;

}

int Array::getData(int index) {
    return data[index];
}

ostream &operator<<(ostream &out, Array &array) {
    cout << "operator<<" << endl;
    for (int i = 0; i < array.getMLength(); i++) {
        cout << array.getData(i) << " ";
    }
    cout << endl;
    return out;
}

istream &operator>>(istream &in, Array &array) {
    cout << "&operator>>" << endl;
    for (int i = 0; i < array.mLength; i++) {
        in >> array[i];
    }
    return in;
}
  • main.cpp
#include <iostream>
#include "Array.h"

using namespace std;

int main() {
    Array array(3);
    for (int i = 0; i < array.getMLength(); i++) {
        array[i] = i * 10;
    }
    array.print();
    Array array1 = array;
    array1.print();
    Array array2(0);
    array2 = array;
    array2.print();
    Array array3(2);
    Array array4 = array3(array);
    array4.print();
    Array array5 = array + array1;
    cout << array5;
    Array array6(5);
    cin >> array6;
    cout << array6;
    return 0;
}
  • 运行结果
0 10 20
copy construct func
0 10 20
operator=
0 10 20
copy construct func
0 10 20
operator+
0 10 20 0 10 20
0 10 20
0 10 20
operator<<
0 10 20 0 10 20
&operator>>
1
1
2
2
3
3
4
4
5
5
operator<<
1 2 3 4 5

Process finished with exit code 0

相关文章

  • Kotlin --- Operator Overloading

    简述 Kotlin的操作符重载与C++类似,虽然没有C++那么强大,但是仍然可以实现Kotlin的操作符重载。 操...

  • C++基础-(重载)

    C++基础 重载 哪些运算符可以被重载:::,.,->,*,?:不能被重载 重载操作符的标志(operator) ...

  • C++中的操作符重载

    操作符重载 C++中的重载能够扩展操作符的功能 操作符的重载以函数的方式进行 本质:用特殊形式的函数扩展操作符的功...

  • C++学习笔记(七)操作符重载(上)

    1、基本操作符重载 操作符重载指的是将C++提供的操作符进行重新定义,使之满足我们所需要的一些功能。 在C++中可...

  • C++ 操作符重载

    操作符重载 操作符的重载是在实际的C++编程过程中不太容易引人注意但却非常实用的一个特性。合理的实现操作符重载可以...

  • 《C++ Primer Plus》第11章学习笔记

    内容思维导图 1. 操作符重载 操作符重载(Operator overloading)是一种形式的C++多态。第8...

  • 1.2.20_C++ 下标运算符 [] 重载

    C++ 重载运算符和重载函数 下标操作符 [] 通常用于访问数组元素。重载该运算符用于增强操作 C++ 数组的功能...

  • Geekband C++ 第五周

    概述 C++模板简介 函数模板 C++类模板 操作符重载 泛型编程 容器

  • 没有学不会的C++:复制操作符怎么写

    C++ 中的操作符重载可以让我们的代码更符合人们的阅读习惯,而 operator= 赋值操作符又是最常被重载的操作...

  • C++操作符重载

    重载操作符的限制 可以重载的操作符 不能重载的算符 操作符重载的语法形式 重载赋值操作符 重载+-*/运算操作符操...

网友评论

      本文标题:c++操作符重载

      本文链接:https://www.haomeiwen.com/subject/jrvurxtx.html