实验测试1《C++ Primer》第五版——第十三章 拷贝控制

String.h

#ifndef STRING_H
#define STRING_H

#include <cstring>
#include <algorithm>
#include <cstddef>
#include <iostream>
#include <iostream>
#include <memory>

using namespace std;

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

public:

String() : sz(0), p(nullptr) {
}

String(const char *cp) : sz(std::strlen(cp)), p(a.allocate(sz)) {
cout << "String(const char *cp)" << endl;
uninitialized_copy(cp, cp + sz, p);
}

String(const String &s) : sz(s.sz), p(a.allocate(s.sz)) {
cout << "String(const String &s)" << endl;
uninitialized_copy(s.p, s.p + sz, p);
}

String(String &&s) : sz(s.sz), p(s.p) {
cout << "String(String &&s)" << endl;
s.p = nullptr;
s.sz = 0;
}

~String() {
cout << "~String()" << endl;
if (p) a.deallocate(p, sz);
}

String &operator=(const String &);

String &operator=(String&&);

String &operator=(const char*);

const char *begin() {
return p;
}

const char *begin() const {
return p;
}

const char *end() {
return p + sz;
}

const char *end() const {
return p + sz;
}

size_t size() const {
return sz;
}

void swap(String &s) {
char *tmp = p;
p = s.p;
s.p = tmp;
size_t cnt = sz;
sz = s.sz;
s.sz = cnt;
}

private:
size_t sz;
char *p;
static allocator<char> a;
};

#endif /* STRING_H */

String.cpp

#include "String.h"

std::allocator<char> String::a;

String &String::operator=(const String &s) {
cout << "operator=(const String &s)" << endl;
char *newp = a.allocate(s.sz);
uninitialized_copy(s.p, s.p + s.sz, newp);

if (p)
a.deallocate(p, sz);
p = newp;
sz = s.sz;

return *this;
}

String &String::operator=(String &&s) {
cout << "operator=(String &&s)" << endl;

if (p)
a.deallocate(p, sz);

p = s.p;
sz = s.sz;

s.p = nullptr;
s.sz = 0;

return *this;
}

String &String::operator=(const char *cp) {
cout << "operator=(const char *cp)" << endl;
if (p) a.deallocate(p, sz);
p = a.allocate(sz = strlen(cp));
uninitialized_copy(cp, cp + sz, p);

return *this;
}

ostream &operator<<(ostream &os, const String &s) {
const char *p = s.begin();
while (p != s.end())
os << *p++ ;
return os;
}

String operator+(const String &lhs, const String &rhs) {
String ret;
ret.sz = rhs.size() + lhs.size();
ret.p = String::a.allocate(ret.sz);
uninitialized_copy(lhs.begin(), lhs.end(), ret.p);
uninitialized_copy(rhs.begin(), rhs.end(), ret.p + lhs.sz);
return ret;
}

main.cc

#include "String.h"

using namespace std;

int main(int argc, char* argv[]) {
allocator<String> alloc;
auto const p = alloc.allocate(4);

String s1("String1");
String s2 = s1;
String s3 = move(s1);
String s4(move(s2));
cout << "s1:" << s1 << endl;
cout << "s2:" << s2 << endl;
cout << "s3:" << s3 << endl;
cout << "s4:" << s4 << endl;

return 0;
}

输出结果

String(const char *cp)
String(const String &s)
String(String &&s)
String(String &&s)
s1:
s2:
s3:String1
s4:String1
~String()
~String()
~String()
~String()