當前位置：首頁 > 人文社科 > 生活经验 >内容正文

生活经验

【C++】重载运算符（一）

發布時間：2023/11/27 生活经验 22 豆豆

生活随笔收集整理的這篇文章主要介紹了【C++】重载运算符（一）小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

1.1 重載運算符特點

重載運算符本質上是一次函數調用
除了operator() 運算符調用外，其他重載運算符不能含有默認參數。
當重載的運算符是成員函數時，this綁定到左側運算對象。成員運算符函數（顯式）的參數數量比運算對象少一個。

運算符重載列表

該將運算符定義為成員函數還是普通成員？參考是什么，如下。

Exercise 14.1: 重載操作符與內置操作符有哪些不同?重載操作符在哪些方面與內置操作符相同?

不同點

我們可以直接調用重載的operator函數。
重載操作符函數必須是類的成員或具有至少一個類類型形參。
少數操作符保證操作數求值的順序。這些操作符的重載版本不能保持求值和/或短路求值的順序，重載它們通常是一個壞主意。
特別是，不保留邏輯與、邏輯或和逗號操作符的操作數求值保證。而且，重載版本的&&或||操作符不保留內置操作符的短路求值屬性。兩個操作數總是被求值。

相同點

重載操作符與相應的內置操作符具有相同的優先級和結合性。

Exercise 14.2: 為Sales_data重載的輸入、輸出、加法和復合賦值運算符。

#include "ex14_02.h"
Sales_data::Sales_data(std::istream &is) : Sales_data()
{is >> *this;
}Sales_data& Sales_data::operator+=(const Sales_data &rhs)
{units_sold += rhs.units_sold;revenue += rhs.revenue;return *this;
}std::istream& operator>>(std::istream &is, Sales_data &item)
{double price = 0.0;is >> item.bookNo >> item.units_sold >> price;if (is)item.revenue = price * item.units_sold;elseitem = Sales_data();return is;
}std::ostream& operator<<(std::ostream &os, const Sales_data &item)
{os << item.isbn() << " " << item.units_sold << " " << item.revenue << " " << item.avg_price();return os;
}Sales_data operator+(const Sales_data &lhs, const Sales_data &rhs)
{Sales_data sum = lhs;sum += rhs;return sum;
}

//  @Add overloaded input, output, addition, and compound-assignment operators#ifndef CP5_CH14_EX14_02_H
#define CP5_CH14_EX14_02_H#include <string>
#include <iostream>class Sales_data {friend std::istream& operator>>(std::istream&, Sales_data&); // inputfriend std::ostream& operator<<(std::ostream&, const Sales_data&); // outputfriend Sales_data operator+(const Sales_data&, const Sales_data&); // additionpublic:Sales_data(const std::string &s, unsigned n, double p):bookNo(s), units_sold(n), revenue(n*p){ }Sales_data() : Sales_data("", 0, 0.0f){ }Sales_data(const std::string &s) : Sales_data(s, 0, 0.0f){ }Sales_data(std::istream &is);Sales_data& operator+=(const Sales_data&); // compound-assignmentstd::string isbn() const { return bookNo; }private:inline double avg_price() const;std::string bookNo;unsigned units_sold = 0;double revenue = 0.0;
};std::istream& operator>>(std::istream&, Sales_data&);
std::ostream& operator<<(std::ostream&, const Sales_data&);
Sales_data operator+(const Sales_data&, const Sales_data&);inline double Sales_data::avg_price() const
{return units_sold ? revenue/units_sold : 0;
}#endif // CP5_CH14_EX14_02_H

Exercise 14.3: string和vector都定義了重載的==，可用于比較這些類型的對象。假設svec1和svec2是保存字符串的向量，確定下面每個表達式中應用了哪個版本的==:

為什么以下語句沒有調用重載的操作符== (const String &， const String &)?

因為在c++中，字符串字面值的類型是const char[]( zero-terminated string constant 也稱為零結束字符串常量)

有一個內置的操作符==通過比較兩個char*的地址來比較它們。由于數組隱式地可轉換為指向其第一個元素的指針（這是C繼承)，因此需要使用這個操作符，比較的是內存中這些字面值的地址。

假設你的String類有一個從const char* (String::String(const char*))的隱式轉換構造函數，你可以將其中一個轉換為String。另一個字符串將被隱式轉換:

String("cobble") == "stone"

(除非為了提高效率，提供了operator==和const char*的重載。如果提供了，他們就會介入。)

Reference

Why does the following not invoke the overloaded operator== (const String &, const String &)? “cobble” == “stone”

Exercise 14.5: 在7.5.1(第291頁)的練習7.40中，您編寫了以下類之一的框架。決定類應該提供什么重載操作符？

Such as Book

#include <iostream>
#include <string>class Book {friend std::istream& operator>>(std::istream&, Book&);friend std::ostream& operator<<(std::ostream&, const Book&);friend bool operator==(const Book&, const Book&);friend bool operator!=(const Book&, const Book&);public:Book() = default;Book(unsigned no, std::string name, std::string author, std::string pubdate):no_(no), name_(name), author_(author), pubdate_(pubdate) { }Book(std::istream &in) { in >> *this; }private:unsigned no_;std::string name_;std::string author_;std::string pubdate_;
};std::istream& operator>>(std::istream&, Book&);
std::ostream& operator<<(std::ostream&, const Book&);
bool operator==(const Book&, const Book&);
bool operator!=(const Book&, const Book&);

#include "ex14_05.h"std::istream& operator>>(std::istream &in, Book &book)
{in >> book.no_ >> book.name_ >> book.author_ >> book.pubdate_;return in;
}std::ostream& operator<<(std::ostream &out, const Book &book)
{out << book.no_ << " " << book.name_ << " " << book.author_ << " " << book.pubdate_;return out;
}bool operator==(const Book &lhs, const Book &rhs)
{return lhs.no_ == rhs.no_;
}bool operator!=(const Book &lhs, const Book &rhs)
{return !(lhs == rhs);
}

Test

#include "ex14_05.h"int main()
{Book book1(123, "CP5", "Lippman", "2012");Book book2(123, "CP5", "Lippman", "2012");if (book1 == book2)std::cout << book1 << std::endl;
}

1.2 輸入輸出運算符

幾點注意事項：

ostream無法賦值

與iostream標準庫兼容的輸入輸出運算符必須是非成員函數（普通非成員函數）

如果，要定義類的自定義的IO運算符，則必須要定義其非成員函數。

IO運算符需要讀寫類的非共有數據成員,因此，IO運算符一般被聲明為友元（P241）。

2.1 重載輸出運算符 <<

通常，輸出運算符第一個形參是一個非常量ostream對象的引用，第二個形參是一個待輸出類類型的常量引用（不改變類內容）

Exercise 14.6: 為Sales_data類定義一個輸出操作符： see Exercise 14.2.

std::ostream& operator<<(std::ostream &os, const Sales_data &item)
{os << item.isbn() << " " << item.units_sold << " " << item.revenue << " " << item.avg_price();return os;
}

**Exercise 14.7:**為 String 類定義一個輸出操作符（P470）

#ifndef CP5_CH14_EX07_H_
#define CP5_CH14_EX07_H_#include <memory>
#include <iostream>class String
{friend std::ostream& operator<<(std::ostream&, const String&);
public:String() : String("") { }String(const char *);String(const String&);String& operator=(const String&);~String();const char *c_str() const { return elements; }size_t size() const { return end - elements; }size_t length() const { return end - elements - 1; }private:std::pair<char*, char*> alloc_n_copy(const char*, const char*);void range_initializer(const char*, const char*);void free();private:char *elements;char *end;std::allocator<char> alloc;
};std::ostream& operator<<(std::ostream&, const String&);

#include "ex14_07.h"
#include <algorithm>
#include <iostream>std::pair<char*, char*>
String::alloc_n_copy(const char *b, const char *e)
{auto str = alloc.allocate(e - b);return{ str, std::uninitialized_copy(b, e, str) };
}void String::range_initializer(const char *first, const char *last)
{auto newstr = alloc_n_copy(first, last);elements = newstr.first;end = newstr.second;
}String::String(const char *s)
{char *sl = const_cast<char*>(s);while (*sl)++sl;range_initializer(s, ++sl);
}String::String(const String& rhs)
{range_initializer(rhs.elements, rhs.end);std::cout << "copy constructor" << std::endl;
}void String::free()
{if (elements) {std::for_each(elements, end, [this](char &c){ alloc.destroy(&c); });alloc.deallocate(elements, end - elements);}
}String::~String()
{free();
}String& String::operator = (const String &rhs)
{auto newstr = alloc_n_copy(rhs.elements, rhs.end);free();elements = newstr.first;end = newstr.second;std::cout << "copy-assignment" << std::endl;return *this;
}std::ostream& operator<<(std::ostream &os, const String &s)
{char *c = const_cast<char*>(s.c_str());while (*c)os << *c++;return os;
}

#include "ex14_07.h"int main()
{String str("Hello World");std::cout << str << std::endl;
}

2.2 重載輸入運算符 >>

通常，第一個形參是讀取流的引用，第二個形參是將要讀入對象（非常量）的引用

std::istream& operator>>(std::istream &is, Sales_data &item)
{double price = 0.0;is >> item.bookNo >> item.units_sold >> price;if (is)item.revenue = price * item.units_sold;elseitem = Sales_data();return is;
}

1.3 算術運算符和關系運算符

通常，算術和關系運算符定義成非成員函數，允許對左側右側的運算對象進行轉換
如相等運算符與不等運算符可以把工作委托給另外一個。
關系運算符定義順序關系，應該與關聯容器中的關鍵字要求保持一致（P378）。

Exercise 14.7:如上Exercise 14.5，Book類的相等運算符。

`StrVec` 實例演示(你想要的全都有)（ ex14_18）

#ifndef CP5_STRVEC_H_
#define CP5_STRVEC_H_#include <memory>
#include <string>
#include <initializer_list>#ifndef _MSC_VER
#define NOEXCEPT noexcept
#else
#define NOEXCEPT
#endifclass StrVec
{friend bool operator==(const StrVec&, const StrVec&);friend bool operator!=(const StrVec&, const StrVec&);friend bool operator< (const StrVec&, const StrVec&);friend bool operator> (const StrVec&, const StrVec&);friend bool operator<=(const StrVec&, const StrVec&);friend bool operator>=(const StrVec&, const StrVec&);public:StrVec() : elements(nullptr), first_free(nullptr), cap(nullptr) { }StrVec(std::initializer_list<std::string>);StrVec(const StrVec&);StrVec& operator=(const StrVec&);StrVec(StrVec&&) NOEXCEPT;StrVec& operator=(StrVec&&)NOEXCEPT;~StrVec();void push_back(const std::string&);size_t size() const { return first_free - elements; }size_t capacity() const { return cap - elements; }std::string *begin() const { return elements; }std::string *end() const { return first_free; }std::string& at(size_t pos) { return *(elements + pos); }const std::string& at(size_t pos) const { return *(elements + pos); }void reserve(size_t new_cap);void resize(size_t count);void resize(size_t count, const std::string&);private:std::pair<std::string*, std::string*> alloc_n_copy(const std::string*, const std::string*);void free();void chk_n_alloc() { if (size() == capacity()) reallocate(); }void reallocate();void alloc_n_move(size_t new_cap);void range_initialize(const std::string*, const std::string*);private:std::string *elements;std::string *first_free;std::string *cap;std::allocator<std::string> alloc;
};bool operator==(const StrVec&, const StrVec&);
bool operator!=(const StrVec&, const StrVec&);
bool operator< (const StrVec&, const StrVec&);
bool operator> (const StrVec&, const StrVec&);
bool operator<=(const StrVec&, const StrVec&);
bool operator>=(const StrVec&, const StrVec&);#endif

#include "ex13_39.h"void StrVec::push_back(const std::string &s)
{chk_n_alloc();alloc.construct(first_free++, s);
}std::pair<std::string*, std::string*>
StrVec::alloc_n_copy(const std::string *b, const std::string *e)
{auto data = alloc.allocate(e - b);return{ data, std::uninitialized_copy(b, e, data) };
}void StrVec::free()
{if (elements) {for (auto p = first_free; p != elements;)alloc.destroy(--p);alloc.deallocate(elements, cap - elements);}
}StrVec::StrVec(const StrVec &rhs)
{auto newdata = alloc_n_copy(rhs.begin(), rhs.end());elements = newdata.first;first_free = cap = newdata.second;
}StrVec::~StrVec()
{free();
}StrVec& StrVec::operator = (const StrVec &rhs)
{auto data = alloc_n_copy(rhs.begin(), rhs.end());free();elements = data.first;first_free = cap = data.second;return *this;
}void StrVec::alloc_n_move(size_t new_cap)
{auto newdata = alloc.allocate(new_cap);auto dest = newdata;auto elem = elements;for (size_t i = 0; i != size(); ++i)alloc.construct(dest++, std::move(*elem++));free();elements = newdata;first_free = dest;cap = elements + new_cap;
}void StrVec::reallocate()
{auto newcapacity = size() ? 2 * size() : 1;alloc_n_move(newcapacity);
}void StrVec::reserve(size_t new_cap)
{if (new_cap <= capacity()) return;alloc_n_move(new_cap);
}void StrVec::resize(size_t count)
{resize(count, std::string());
}void StrVec::resize(size_t count, const std::string &s)
{if (count > size()) {if (count > capacity()) reserve(count * 2);for (size_t i = size(); i != count; ++i)alloc.construct(first_free++, s);}else if (count < size()) {while (first_free != elements + count)alloc.destroy(--first_free);}
}int main()
{return 0;
}

#include "ex14_16_StrVec.h"
#include <iostream>
#include <vector>int main()
{StrVec vec;vec.reserve(6);std::cout << "capacity(reserve to 6): " << vec.capacity() << std::endl;vec.reserve(4);std::cout << "capacity(reserve to 4): " << vec.capacity() << std::endl;vec.push_back("hello");vec.push_back("world");vec.resize(4);for (auto i = vec.begin(); i != vec.end(); ++i)std::cout << *i << std::endl;std::cout << "-EOF-" << std::endl;vec.resize(1);for (auto i = vec.begin(); i != vec.end(); ++i)std::cout << *i << std::endl;std::cout << "-EOF-" << std::endl;StrVec vec_list{ "hello", "world", "pezy" };for (auto i = vec_list.begin(); i != vec_list.end(); ++i)std::cout << *i << " ";std::cout << std::endl;// Test operator==const StrVec const_vec_list{ "hello", "world", "pezy" };if (vec_list == const_vec_list)for (const auto &str : const_vec_list)std::cout << str << " ";std::cout << std::endl;
}

`StrBlob` & `StrBlobPtr` 實例演示(你想要的全都有)

/*
=================================================================================
C++ Primer 5th Exercise Answer Source Code
StrBlob, StrBlobPtr, ConstStrBlobPtr
If you have questions, try to connect with me: pezy<urbancpz@gmail.com>
=================================================================================
*/#ifndef CP5_STRBLOB_H_
#define CP5_STRBLOB_H_#include <vector>
using std::vector;#include <string>
using std::string;#include <initializer_list>
using std::initializer_list;#include <memory>
using std::make_shared; using std::shared_ptr;#include <exception>#ifndef _MSC_VER
#define NOEXCEPT noexcept
#else
#define NOEXCEPT
#endifclass StrBlobPtr;
class ConstStrBlobPtr;//=================================================================================
//
//		StrBlob - custom vector<string>
//
//=================================================================================class StrBlob {using size_type = vector<string>::size_type;friend class ConstStrBlobPtr;friend class StrBlobPtr;friend bool operator==(const StrBlob&, const StrBlob&);friend bool operator!=(const StrBlob&, const StrBlob&);public:StrBlob() : data(make_shared<vector<string>>()) { }StrBlob(initializer_list<string> il) : data(make_shared<vector<string>>(il)) { }StrBlob(const StrBlob &sb) : data(make_shared<vector<string>>(*sb.data)) { }StrBlob& operator=(const StrBlob&);StrBlob(StrBlob &&rhs) NOEXCEPT : data(std::move(rhs.data)) { }StrBlob& operator=(StrBlob &&)NOEXCEPT;StrBlobPtr begin();StrBlobPtr end();ConstStrBlobPtr cbegin() const;ConstStrBlobPtr cend() const;size_type size() const { return data->size(); }bool empty() const { return data->empty(); }void push_back(const string &t) { data->push_back(t); }void push_back(string &&s) { data->push_back(std::move(s)); }void pop_back();string& front();string& back();const string& front() const;const string& back() const;private:void check(size_type, const string&) const;shared_ptr<vector<string>> data;
};bool operator==(const StrBlob&, const StrBlob&);
bool operator!=(const StrBlob&, const StrBlob&);inline void StrBlob::pop_back()
{check(0, "pop_back on empty StrBlob");data->pop_back();
}inline string& StrBlob::front()
{check(0, "front on empty StrBlob");return data->front();
}inline string& StrBlob::back()
{check(0, "back on empty StrBlob");return data->back();
}inline const string& StrBlob::front() const
{check(0, "front on empty StrBlob");return data->front();
}inline const string& StrBlob::back() const
{check(0, "back on empty StrBlob");return data->back();
}inline void StrBlob::check(size_type i, const string &msg) const
{if (i >= data->size()) throw std::out_of_range(msg);
}//=================================================================================
//
//		StrBlobPtr - custom iterator of StrBlob
//
//=================================================================================class StrBlobPtr {friend bool operator==(const StrBlobPtr&, const StrBlobPtr&);friend bool operator!=(const StrBlobPtr&, const StrBlobPtr&);
public:StrBlobPtr() : curr(0) { }StrBlobPtr(StrBlob &s, size_t sz = 0) : wptr(s.data), curr(sz) { }string& deref() const;StrBlobPtr& incr();private:shared_ptr<vector<string>> check(size_t, const string&) const;std::weak_ptr<vector<string>> wptr;size_t curr;
};bool operator==(const StrBlobPtr&, const StrBlobPtr&);
bool operator!=(const StrBlobPtr&, const StrBlobPtr&);inline string& StrBlobPtr::deref() const
{auto p = check(curr, "dereference past end");return (*p)[curr];
}inline StrBlobPtr& StrBlobPtr::incr()
{check(curr, "increment past end of StrBlobPtr");++curr;return *this;
}inline shared_ptr<vector<string>> StrBlobPtr::check(size_t i, const string &msg) const
{auto ret = wptr.lock();if (!ret) throw std::runtime_error("unbound StrBlobPtr");if (i >= ret->size()) throw std::out_of_range(msg);return ret;
}//=================================================================================
//
//		ConstStrBlobPtr - custom const_iterator of StrBlob
//
//=================================================================================class ConstStrBlobPtr {friend bool operator==(const ConstStrBlobPtr&, const ConstStrBlobPtr&);friend bool operator!=(const ConstStrBlobPtr&, const ConstStrBlobPtr&);public:ConstStrBlobPtr() : curr(0) { }ConstStrBlobPtr(const StrBlob &s, size_t sz = 0) : wptr(s.data), curr(sz) { }const string& deref() const;ConstStrBlobPtr& incr();private:std::shared_ptr<vector<string>> check(size_t, const string&) const;std::weak_ptr<vector<string>> wptr;size_t curr;
};inline const string& ConstStrBlobPtr::deref() const
{auto p = check(curr, "dereference past end");return (*p)[curr];
}inline ConstStrBlobPtr& ConstStrBlobPtr::incr()
{check(curr, "increment past end of StrBlobPtr");++curr;return *this;
}inline std::shared_ptr<vector<string>> ConstStrBlobPtr::check(size_t i, const string &msg) const
{auto ret = wptr.lock();if (!ret) throw std::runtime_error("unbound StrBlobPtr");if (i >= ret->size()) throw std::out_of_range(msg);return ret;
}bool operator==(const ConstStrBlobPtr&, const ConstStrBlobPtr&);
bool operator!=(const ConstStrBlobPtr&, const ConstStrBlobPtr&);#endif //CP5_STRBLOB_H_

#include "ex14_16_StrBlob.h"//==================================================================
//
//		operators
//
//==================================================================bool operator==(const StrBlob &lhs, const StrBlob &rhs)
{return *lhs.data == *rhs.data;
}bool operator!=(const StrBlob &lhs, const StrBlob &rhs)
{return !(lhs == rhs);
}bool operator==(const StrBlobPtr &lhs, const StrBlobPtr &rhs)
{return lhs.curr == rhs.curr;
}bool operator!=(const StrBlobPtr &lhs, const StrBlobPtr &rhs)
{return !(lhs == rhs);
}bool operator==(const ConstStrBlobPtr &lhs, const ConstStrBlobPtr &rhs)
{return lhs.curr == rhs.curr;
}bool operator!=(const ConstStrBlobPtr &lhs, const ConstStrBlobPtr &rhs)
{return !(lhs == rhs);
}//==================================================================
//
//		copy assignment operator and move assignment operator.
//
//==================================================================StrBlob& StrBlob::operator=(const StrBlob &lhs)
{data = make_shared<vector<string>>(*lhs.data);return *this;
}StrBlob& StrBlob::operator=(StrBlob &&rhs) NOEXCEPT
{if (this != &rhs) {data = std::move(rhs.data);rhs.data = nullptr;}return *this;
}//==================================================================
//
//		members
//
//==================================================================StrBlobPtr StrBlob::begin()
{return StrBlobPtr(*this);
}StrBlobPtr StrBlob::end()
{return StrBlobPtr(*this, data->size());
}ConstStrBlobPtr StrBlob::cbegin() const
{return ConstStrBlobPtr(*this);
}ConstStrBlobPtr StrBlob::cend() const
{return ConstStrBlobPtr(*this, data->size());
}

#include "ex14_16_StrBlob.h"
#include <iostream>int main()
{StrBlob sb{ "Hello", "World", "Pezy" };for (ConstStrBlobPtr iter = sb.cbegin(); iter != sb.cend(); iter.incr()) {std::cout << iter.deref() << " ";}std::cout << std::endl;
}

`String` 實例演示(你想要的全都有)

#ifndef CP5_STRING_H__
#define CP5_STRING_H__#include <memory>
#include <iostream>#ifndef _MSC_VER
#define NOEXCEPT noexcept
#else
#define NOEXCEPT
#endifclass String
{friend std::ostream& operator<<(std::ostream&, const String&);friend std::istream& operator>>(std::istream&, String&);friend bool operator==(const String&, const String&);friend bool operator!=(const String&, const String&);public:String() : String("") { }String(const char *);String(const String&);String& operator=(const String&);String(String &&) NOEXCEPT;String& operator=(String&&)NOEXCEPT;~String();void push_back(const char);char* begin() const { return elements; }char* end() const { return last_elem; }const char *c_str() const { return elements; }size_t size() const { return last_elem - elements; }size_t length() const { return size(); }size_t capacity() const { return cap - elements; }void reserve(size_t);void resize(size_t);void resize(size_t, char);private:std::pair<char*, char*> alloc_n_copy(const char*, const char*);void range_initializer(const char*, const char*);void free();void reallocate();void alloc_n_move(size_t new_cap);void chk_n_alloc() { if (first_free == cap) reallocate(); }private:char *elements;char *last_elem;char *first_free;char *cap;std::allocator<char> alloc;
};std::ostream& operator<<(std::ostream&, const String&);
std::istream& operator>>(std::istream&, String&);
bool operator==(const String&, const String&);
bool operator!=(const String&, const String&);#endif

		#include "ex14_16_String.h"
#include <algorithm>//===========================================================================
//
//		operator - friend
//
//===========================================================================std::ostream& operator<<(std::ostream &os, const String &lhs)
{os << lhs.c_str();return os;
}std::istream& operator>>(std::istream &is, String &rhs)
{for (char c; (c = is.get()) != '\n';) {rhs.push_back(c);}return is;
}bool operator==(const String &lhs, const String &rhs)
{return (lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin()));
}bool operator!=(const String &lhs, const String &rhs)
{return !(lhs == rhs);
}//===========================================================================
//
//		Constructors
//
//===========================================================================String::String(const char *s)
{char *sl = const_cast<char*>(s);while (*sl)++sl;range_initializer(s, ++sl);
}//===========================================================================
//
//		Big 5
//
//===========================================================================String::String(const String& rhs)
{range_initializer(rhs.elements, rhs.first_free);
}String& String::operator = (const String &rhs)
{auto newstr = alloc_n_copy(rhs.elements, rhs.first_free);free();elements = newstr.first;first_free = cap = newstr.second;last_elem = first_free - 1;return *this;
}String::String(String &&s) NOEXCEPT : elements(s.elements), last_elem(s.last_elem), first_free(s.first_free), cap(s.cap)
{s.elements = s.last_elem = s.first_free = s.cap = nullptr;
}String& String::operator = (String &&rhs) NOEXCEPT
{if (this != &rhs) {free();elements = rhs.elements;last_elem = rhs.last_elem;first_free = rhs.first_free;cap = rhs.cap;rhs.elements = rhs.last_elem = rhs.first_free = rhs.cap = nullptr;}return *this;
}String::~String()
{free();
}//===========================================================================
//
//		members
//
//===========================================================================void String::push_back(const char c)
{chk_n_alloc();*last_elem = c;last_elem = first_free;alloc.construct(first_free++, '\0');
}void String::reallocate()
{//	\0    |    -//  ^          ^// elements    first_free// last_elem   capauto newcapacity = size() ? 2 * (size() + 1) : 2;alloc_n_move(newcapacity);
}void String::alloc_n_move(size_t new_cap)
{auto newdata = alloc.allocate(new_cap);auto dest = newdata;auto elem = elements;for (size_t i = 0; i != size() + 1; ++i)alloc.construct(dest++, std::move(*elem++));free();elements = newdata;last_elem = dest - 1;first_free = dest;cap = elements + new_cap;
}void String::free()
{if (elements) {std::for_each(elements, first_free, [this](char &c){ alloc.destroy(&c); });alloc.deallocate(elements, cap - elements);}
}std::pair<char*, char*>
String::alloc_n_copy(const char *b, const char *e)
{auto str = alloc.allocate(e - b);return{ str, std::uninitialized_copy(b, e, str) };
}void String::range_initializer(const char *first, const char *last)
{auto newstr = alloc_n_copy(first, last);elements = newstr.first;first_free = cap = newstr.second;last_elem = first_free - 1;
}void String::reserve(size_t new_cap)
{if (new_cap <= capacity()) return;alloc_n_move(new_cap);
}void String::resize(size_t count, char c)
{if (count > size()) {if (count > capacity()) reserve(count * 2);for (size_t i = size(); i != count; ++i) {*last_elem++ = c;alloc.construct(first_free++, '\0');}}else if (count < size()) {while (last_elem != elements + count) {--last_elem;alloc.destroy(--first_free);}*last_elem = '\0';}
}void String::resize(size_t count)
{resize(count, ' ');
}

#include <algorithm>
#include <iterator>
#include <string>void foo(String x)
{std::cout << x << std::endl;
}void bar(const String& x)
{std::cout << x.c_str() << std::endl;
}String baz()
{String ret("world");return ret;
}int main()
{char text[] = "world";String s0;String s1("hello");String s2(std::move(s0));String s3 = s1;String s4(text);s2 = s1;if (s2 == s1)std::cout << "s2 == s1" << std::endl;foo(s1);bar(s1);foo("temporary");bar("temporary");String s5 = baz();std::vector<String> svec;//svec.push_back(s0);svec.push_back(s1);svec.push_back(s2);svec.push_back(s3);svec.push_back(s4);svec.push_back(baz());svec.push_back("good job");for (const auto &s : svec) {std::cout << s << std::endl;}std::cout << "Input a string: ";String s6;std::cin >> s6;std::cout << s6 << std::endl;
}

1.4 賦值運算符

賦值運算符必須定義為類的成員，復合賦值運算符通常定義為類的成員。

這2個運算符都必須返回左側運算對象的引用 * this

Exercise 14.21:實例如下

栗子1：

Sales_data& Sales_data：：operator+= (const Sales_data &rhs){units_sold += rhs.units_sold;revenue += rhs.revenue;return *this;
}

栗子2：

Sales_data& Sales_data::operator+=(const Sales_data &rhs)
{Sales_data old_data = *this;*this = old_data + rhs;return *this;
}Sales_data operator+(const Sales_data &lhs, const Sales_data &rhs)
{Sales_data sum;sum.units_sold = lhs.units_sold + rhs.units_sold;sum.revenue = lhs.revenue + rhs.revenue;return sum;
}

Disadvantages: +和+=都使用Sales_data的臨時對象。但這是沒有必要的。

Exercise 14.22:

定義賦值操作符的一個版本，可以將表示ISBN的字符串賦值給Sales_data。

#include <string>
#include <iostream>class Sales_data {friend std::istream& operator>>(std::istream&, Sales_data&);friend std::ostream& operator<<(std::ostream&, const Sales_data&);friend Sales_data operator+(const Sales_data&, const Sales_data&);public:Sales_data(const std::string &s, unsigned n, double p):bookNo(s), units_sold(n), revenue(n*p){ }Sales_data() : Sales_data("", 0, 0.0f){ }Sales_data(const std::string &s) : Sales_data(s, 0, 0.0f){ }Sales_data(std::istream &is);Sales_data& operator=(const std::string&);Sales_data& operator+=(const Sales_data&);std::string isbn() const { return bookNo; }private:inline double avg_price() const;std::string bookNo;unsigned units_sold = 0;double revenue = 0.0;
};std::istream& operator>>(std::istream&, Sales_data&);
std::ostream& operator<<(std::ostream&, const Sales_data&);
Sales_data operator+(const Sales_data&, const Sales_data&);inline double Sales_data::avg_price() const
{return units_sold ? revenue/units_sold : 0;
}

#include "ex14_22.h"Sales_data::Sales_data(std::istream &is) : Sales_data()
{is >> *this;
}Sales_data& Sales_data::operator+=(const Sales_data &rhs)
{units_sold += rhs.units_sold;revenue += rhs.revenue;return *this;
}std::istream& operator>>(std::istream &is, Sales_data &item)
{double price = 0.0;is >> item.bookNo >> item.units_sold >> price;if (is)item.revenue = price * item.units_sold;elseitem = Sales_data();return is;
}std::ostream& operator<<(std::ostream &os, const Sales_data &item)
{os << item.isbn() << " " << item.units_sold << " " << item.revenue << " " << item.avg_price();return os;
}Sales_data operator+(const Sales_data &lhs, const Sales_data &rhs)
{Sales_data sum = lhs;sum += rhs;return sum;
}Sales_data& Sales_data::operator=(const std::string &isbn)
{*this = Sales_data(isbn);return *this;
}

#include "ex14_22.h"int main()
{std::string strCp5("C++ Primer 5th");Sales_data cp5;cp5 = strCp5;std::cout << cp5 << std::endl;
}

Exercise 14.23: 為你的StrVec類定義一個initializer_list賦值操作符。

#include <memory>
#include <string>
#include <initializer_list>#ifndef _MSC_VER
#define NOEXCEPT noexcept
#else
#define NOEXCEPT
#endifclass StrVec
{friend bool operator==(const StrVec&, const StrVec&);friend bool operator!=(const StrVec&, const StrVec&);friend bool operator< (const StrVec&, const StrVec&);friend bool operator> (const StrVec&, const StrVec&);friend bool operator<=(const StrVec&, const StrVec&);friend bool operator>=(const StrVec&, const StrVec&);public:StrVec() : elements(nullptr), first_free(nullptr), cap(nullptr) { }StrVec(std::initializer_list<std::string>);StrVec(const StrVec&);StrVec& operator=(const StrVec&);StrVec(StrVec&&) NOEXCEPT;StrVec& operator=(StrVec&&)NOEXCEPT;~StrVec();StrVec& operator=(std::initializer_list<std::string>);void push_back(const std::string&);size_t size() const { return first_free - elements; }size_t capacity() const { return cap - elements; }std::string *begin() const { return elements; }std::string *end() const { return first_free; }std::string& at(size_t pos) { return *(elements + pos); }const std::string& at(size_t pos) const { return *(elements + pos); }void reserve(size_t new_cap);void resize(size_t count);void resize(size_t count, const std::string&);private:std::pair<std::string*, std::string*> alloc_n_copy(const std::string*, const std::string*);void free();void chk_n_alloc() { if (size() == capacity()) reallocate(); }void reallocate();void alloc_n_move(size_t new_cap);void range_initialize(const std::string*, const std::string*);private:std::string *elements;std::string *first_free;std::string *cap;std::allocator<std::string> alloc;
};bool operator==(const StrVec&, const StrVec&);
bool operator!=(const StrVec&, const StrVec&);
bool operator< (const StrVec&, const StrVec&);
bool operator> (const StrVec&, const StrVec&);
bool operator<=(const StrVec&, const StrVec&);
bool operator>=(const StrVec&, const StrVec&);

#include "ex14_23.h"
#include <algorithm> // for_each, equalvoid StrVec::push_back(const std::string &s)
{chk_n_alloc();alloc.construct(first_free++, s);
}std::pair<std::string*, std::string*>
StrVec::alloc_n_copy(const std::string *b, const std::string *e)
{auto data = alloc.allocate(e - b);return{ data, std::uninitialized_copy(b, e, data) };
}void StrVec::free()
{if (elements) {for_each(elements, first_free, [this](std::string &rhs){ alloc.destroy(&rhs); });alloc.deallocate(elements, cap - elements);}
}void StrVec::range_initialize(const std::string *first, const std::string *last)
{auto newdata = alloc_n_copy(first, last);elements = newdata.first;first_free = cap = newdata.second;
}StrVec::StrVec(const StrVec &rhs)
{range_initialize(rhs.begin(), rhs.end());
}StrVec::StrVec(std::initializer_list<std::string> il)
{range_initialize(il.begin(), il.end());
}StrVec::~StrVec()
{free();
}StrVec& StrVec::operator = (const StrVec &rhs)
{auto data = alloc_n_copy(rhs.begin(), rhs.end());free();elements = data.first;first_free = cap = data.second;return *this;
}void StrVec::alloc_n_move(size_t new_cap)
{auto newdata = alloc.allocate(new_cap);auto dest = newdata;auto elem = elements;for (size_t i = 0; i != size(); ++i)alloc.construct(dest++, std::move(*elem++));free();elements = newdata;first_free = dest;cap = elements + new_cap;
}void StrVec::reallocate()
{auto newcapacity = size() ? 2 * size() : 1;alloc_n_move(newcapacity);
}void StrVec::reserve(size_t new_cap)
{if (new_cap <= capacity()) return;alloc_n_move(new_cap);
}void StrVec::resize(size_t count)
{resize(count, std::string());
}void StrVec::resize(size_t count, const std::string &s)
{if (count > size()) {if (count > capacity()) reserve(count * 2);for (size_t i = size(); i != count; ++i)alloc.construct(first_free++, s);}else if (count < size()) {while (first_free != elements + count)alloc.destroy(--first_free);}
}StrVec::StrVec(StrVec &&s) NOEXCEPT : elements(s.elements), first_free(s.first_free), cap(s.cap)
{// leave s in a state in which it is safe to run the destructor.s.elements = s.first_free = s.cap = nullptr;
}StrVec& StrVec::operator = (StrVec &&rhs) NOEXCEPT
{if (this != &rhs) {free();elements = rhs.elements;first_free = rhs.first_free;cap = rhs.cap;rhs.elements = rhs.first_free = rhs.cap = nullptr;}return *this;
}bool operator==(const StrVec &lhs, const StrVec &rhs)
{return (lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin()));
}bool operator!=(const StrVec &lhs, const StrVec &rhs)
{return !(lhs == rhs);
}bool operator<(const StrVec &lhs, const StrVec &rhs)
{return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}bool operator>(const StrVec &lhs, const StrVec &rhs)
{return rhs < lhs;
}bool operator<=(const StrVec &lhs, const StrVec &rhs)
{return !(rhs < lhs);
}bool operator>=(const StrVec &lhs, const StrVec &rhs)
{return !(lhs < rhs);
}StrVec& StrVec::operator=(std::initializer_list<std::string> il)
{auto data = alloc_n_copy(il.begin(), il.end());free();elements = data.first;first_free = cap = data.second;return *this;
}

#include "ex14_23.h"
#include <iostream>
#include <vector>int main()
{StrVec vec;vec.reserve(6);std::cout << "capacity(reserve to 6): " << vec.capacity() << std::endl;vec.reserve(4);std::cout << "capacity(reserve to 4): " << vec.capacity() << std::endl;vec.push_back("hello");vec.push_back("world");vec.resize(4);for (auto i = vec.begin(); i != vec.end(); ++i)std::cout << *i << std::endl;std::cout << "-EOF-" << std::endl;vec.resize(1);for (auto i = vec.begin(); i != vec.end(); ++i)std::cout << *i << std::endl;std::cout << "-EOF-" << std::endl;StrVec vec_list{ "hello", "world", "pezy" };for (auto i = vec_list.begin(); i != vec_list.end(); ++i)std::cout << *i << " ";std::cout << std::endl;// Test operator==const StrVec const_vec_list = { "hello", "world", "pezy" };if (vec_list == const_vec_list)for (const auto &str : const_vec_list)std::cout << str << " ";std::cout << std::endl;// Test operator<const StrVec const_vec_list_small = { "hello", "pezy", "ok" };std::cout << (const_vec_list_small < const_vec_list) << std::endl;
}

1.4 下標運算符p501

總結

以上是生活随笔為你收集整理的【C++】重载运算符（一）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

运算符