码迷,mamicode.com
首页 > 编程语言 > 详细

0718-----C++Primer听课笔记----------运算符重载

时间:2014-07-19 18:30:05      阅读:206      评论:0      收藏:0      [点我收藏+]

标签:style   blog   color   使用   os   art   

0.两个要点

a) 一个空类,编译器自动合成默认无参构造函数、析构函数、拷贝构造函数、赋值运算符。

b) 在编写类的时候,必须严格区分对象是否可复制

1.运算符重载之 string类

1.1 运算符重载的几个要点:

a) 运算符重载可以有成员函数和友元函数的形式,后者比前者多一个参数。

b) =和+=必须重载为成员函数的形式(不太理解原因)

c) 输入和输出必须为友元函数的形式。而且输入操作符要考虑输入失败的情况。

d) 运算符重载为成员函数的形式,那么该操作符的第一个操作数必然为该类的对象。以+=为例,s += “hello” 那么等价于 s.operator+=(“hello”)。

1.2 String 类源码

#ifndef __STRING_H__
#define __STRING_H__
#include <stddef.h>
#include <iostream>
#include <string.h>

class  String{
    friend std::ostream &operator<<(std::ostream &, const String &);
    friend std::istream &operator>>(std::istream &, String &);

    friend String operator+(const String &, const String &);
    friend String operator+(const String &, const char *);
    friend String operator+(const char *, const String &);
//    friend String &operator+(const char*, const char*);

    friend bool operator==(const String &, const String &);
    friend bool operator!=(const String &, const String &);
    friend bool operator>(const String &, const String &);
    friend bool operator<(const String &, const String &);
    friend bool operator>=(const String &, const String &);
    friend bool operator<=(const String &, const String &);



    public:
        String();
        String(const char* str);
        String(const String &other);
        ~String();

        String &operator= (const String &other);
        String &operator= (const char *str);

        String &operator+= (const String &other);
        String &operator+= (const char *str);

        char &operator[](size_t index);
        char &operator[](size_t index) const;

        size_t size() const;
        void debug() const;
    private:
        char *str_;
};

inline std::ostream &operator<<(std::ostream &os, const String &s){
    return os << s.str_; //将换行权交给调用者
}

inline std::istream &operator>>(std::istream &is, String &s){
    char buf[1024];
    is >> buf;
    if(is){         //输入失败时不改变原对象
        s.str_ = buf;
    }
    return is;
}

inline String operator+(const String &s1, const String &s2){
    String ret(s1); //加法不改变原对象
    ret += s2;
    return ret;
}

inline String operator+(const String &s1, const char *s2){
    return s1 + String(s2);
}

inline String operator+(const char *s1, const String &s2){
    return String(s1) + s2;
}

inline bool operator==(const String &s1, const String &s2){
    return ::strcmp(s1.str_, s2.str_) == 0;
}
inline bool operator!=(const String &s1, const String &s2){
    return  !(s1 == s2);
}
inline bool operator>(const String &s1, const String &s2){
    return ::strcmp(s1.str_, s2.str_) > 0;
}
inline bool operator<(const String &s1, const String &s2){
    return  s2 > s1;
}
inline bool operator>=(const String &s1, const String &s2){
    return !(s1 < s2);
}
inline bool operator<=(const String &s1, const String &s2){
    return !(s1 > s2);
}
#endif


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


String::String()
    :str_ (new char[1])
{
     str_[0] = 0;
}

String::String(const char* str)
    :str_(new char[::strlen(str) + 1])
{
    ::strcpy(str_, str);
}

String::String(const String &other)
    :str_(new char[::strlen(other.str_) + 1])
{
   :: strcpy(str_, other.str_);
}

String::~String(){
    delete[] str_;
}

String& String::operator=(const String &other){
    if(&other != this){
        delete[] str_;
        str_ = new char[::strlen(other.str_) + 1];
        ::strcpy(str_, other.str_);
    }
    return *this;
}

String &String::operator=(const char *str){
    return operator=(String(str));
}

String &String::operator+=(const String &other){
    char *ret = new char[size() + other.size() + 1];
    ret = str_;
    ::strcat(ret, other.str_);
    str_ = ret;
    return *this;
}

String &String::operator+=(const char *str){
    return operator+=(String(str));
}

char &String::operator[](size_t index){
    return str_[index];
}

char &String::operator[](size_t index) const{
    return str_[index];
}
size_t String::size() const{
    return ::strlen(str_);
}
void String::debug()const{
    std::cout << str_ << std::endl;
}

#include "string.h"
#include <iostream>
using namespace std;

int main(int argc, const char *argv[])
{
    String s1("apple");
   // cout << s1 << endl;

    String s3;
    s3 = "hello";

    //cout << "world " + s3 << endl;

    cout << (s1 == s3) << endl;
    cout << (s1 > s3) <<endl;
    cout << (s1 >= s3) << endl;
    return 0;
}
 

2.  自增运算符的重载

2.1 以整形 Integer 类为例,来重载前缀自增运算符(++i)和 后缀自增运算符(i++),这里要注意的几点:

a) 为了区别两个函数,我们将前缀自增运算符的重载函数中增加一个无用的参数。

b) 重载输出操作符的第二个参数 必须是 const, 因为在调用 i++ 时,函数返回值采用值传递,生成了临时对象,注意临时对象是不能修改的 具有const语义,因而此处必须设为const;对于++i 操作 ,该函数返回当前对象的引用,因而是否为const不影响。因此要记住,重载输出操作符时,第二个参数都设为const 引用,这里第一个参数也必须是引用,因为流对象不能复制和赋值。

c) 在生成临时对象的时候调用了拷贝构造函数。

d) Integer(int data)类型的构造函数,具有一种转化语义,能够将int转化为Integer,而加上explicit就禁用掉了转化语义。加上该关键字后,只能采用原生的构造方式如Integer t(100),而不能使用转化形式Integer t = 33。

e)自增操作符,前置和后置的区别:前置直接修改原对象,直接返回; 后置需要暂存之前的结果,修改对象后,将旧的对象返回。

 

2.2 源码

#ifndef __INTEGER_H__
#define __INTEGER_H__

#include <iostream>
class Integer{

    friend  std::ostream &operator<<(std::ostream &os, const Integer &itg);

    public:
        Integer();
        explicit Integer(int data);
        Integer(const Integer &other);
        ~Integer();
        Integer &operator=(const Integer &i);

        /*
         * 为了区别前缀和后缀式 传入一个无用的形参
         */
        Integer &operator++();
        Integer operator++(int);


    private:
        int data_;
};

inline std::ostream &operator<<(std::ostream &os, const Integer &itg){
    return os << itg.data_;
}
#endif
#include "integer.h"

Integer::Integer()
    :data_(0)
{
}

Integer::Integer(int data)
    :data_(data)
{
}

Integer::Integer(const Integer &other)
    :data_(other.data_)
{
    std::cout << "call copy construction" << std::endl;
}

Integer::~Integer()
{
}

Integer &Integer::operator=(const Integer &i){
    data_ = i.data_;
    return *this;
}

Integer &Integer::operator++(){
    std::cout << "call prefix " << std::endl;
    data_++;
    return *this;
}

Integer Integer::operator++(int){//此处的 int无用 因此不用命名
    std::cout << "call postfix" << std::endl;
    Integer ret(*this);
    data_++;
    return ret; //这里函数返回时 生成了临时对象;
}


#include <iostream>
#include "integer.h"
using namespace std;

int main(int argc, const char *argv[])
{
    Integer itg(10);
    cout << itg << endl;
    cout << ++itg << endl;

    Integer itg2(20);
    cout << itg2 << endl;
    cout << itg2++ << endl;
/*
 * 构造函数加上 explicit 之后
 * 再使用这种隐身转换就会报错
    Integer itg3 = 8;
    cout << itg3 << endl;

*/
    return 0;
}

0718-----C++Primer听课笔记----------运算符重载,布布扣,bubuko.com

0718-----C++Primer听课笔记----------运算符重载

标签:style   blog   color   使用   os   art   

原文地址:http://www.cnblogs.com/monicalee/p/3855023.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!