《C++ Premier, 5th Edition》读书总结

int units_sold = 0;
int units_sold = {0};
int units_sold {0};
int units_sold(0);

int x = 10;

// ref is a reference to x.
int &ref = x;

// Value of x is now changed to 20
ref = 20;
cout << "x = " << x << '\n';

// Value of x is now changed to 30
x = 30;
cout << "ref = " << ref << '\n';

int ival = 42;
int *p = &ival;

int ival = 1024;
int *pi = &ival;   // 指向int的指针
int **ppi = π   // 指针的指针

// xxx.cc
// declare & initialize in .cc file
extern const int buffSize = 1024;
// xxx.hpp
// define const in header
extern const int bufSize;

int i = 42, *p = &i, &r = i;
decltype(r + 0) b; 		// correct, b as int type
decltype(*p) c;	   		// incorrect c is int&, must be initialized
decltype((r + 0)) d; 	// incorrect d as int&, must be initialized

constexpr int sum(int x, int y) {
  return x + y;
}

int main() {
  constexpr int a = 5;
  constexpr int b = 7;
  constexpr int result = sum(a, b);
  return 0;
}

string s1 = "";
string s2(s1);
string s3 = s1;
string s3("value");
string s3 = "value";
string s4(n, 'c');

string test_07_16_iterate_str() {
  string s = "Hello World!";
  for (auto &c : s) {
    c = toupper(c);
  }
  cout << "s: " << s << endl;
  return s;
}

// template function for printing the vector
template <typename S>
ostream& operator<<(ostream& os,
                    const vector<S>& vector)
{
    // Printing all the elements
    // using <<
    for (auto element : vector) {
        os << element << " ";
    }
    return os;
}

void test_07_16_vector() {
  vector<int> v1;
  vector<int> v2(v1);
  vector<int> v3 = v1;
  vector<int> v4 = {1, 2, 3, 4, 5};

  v1.push_back(1);
  v1.push_back(2);

  cout << v1 << endl;
  cout << v2 << endl;
}

void test_07_16_iterator_vector() {
  vector<int> v1 = {1, 2, 3, 4, 5};
  // v1.end() points to the position
  // right after the last element
  for (auto it = v1.begin(); it != v1.end(); ++it) {
    *it = *it * 2;
  }
  cout << v1 << endl;
}

std::vector<int> vec = {1, 2, 3, 4, 5};
for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << std::endl;
}

void test_07_16_array() {
  unsigned scores[11] = {};
  unsigned grade;

  for (unsigned element : scores) {
        cout << element << " ";
  }
}

string nums[] = {"one", "two", "three"};
string *p = &nums[0]; // point to the first element in array
string *p1 = nums;    // same as above, here p and p1 is the same

int ia[] = {1, 2, 3, 4, 5};
int *beg = begin(ia);
int *last = end(ia);

int ia[3][4] = {
	{0, 1, 2, 3},
	{4, 5, 6, 7},
	{8, 9, 10, 11}
}

int ia[3][4] = {
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
}

// p 指向第一层数组元素，为第一层数组元素的指针.
for (auto p= ia; p != ia + 3; ++p) {
    // 因为*p 本身反馈第二层数组，
    // 因此q指向4个整数数组的首元素地址指针.
    for (auto q = *p; q != *p + 4; +=q) {
        cout << *q << ' ';
    }
    cout << endl;
}

// p 指向ia 的第一个数组
for (auto p = begin(ia); p != end(ia); ++p) {
    // q 指向内层数组的首个元素
    for (auto q = begin(*p); q != end(*q); ++q) {
        cout << *q << ' ';
    }
}

// TestClass07.hpp

#include <string>

class TestClass07 {
  public:
    TestClass07();
    TestClass07(std::string name);
    ~TestClass07();
    std::string hello();

  private:
    std::string name;
};

// TestClass07.cpp

#include <string>
#include <iostream>

#include "TestClass07.hpp"

using namespace std;

TestClass07::TestClass07() {
    cout << "TestClass07 constructor called." << endl;
}

TestClass07::TestClass07(std::string name) {
    this->name = name;
    cout << "TestClass07 constructor called with name: " << name << endl;
}

TestClass07::~TestClass07() {
    cout << "TestClass07 destructor called." << endl;
}

string TestClass07::hello() {
    return "Hello, " +this-> name + "!";
}

const int a = 10;
int* p = const_cast<int*>(&a);
*p = 20; // Now, a is 20

// 一个函数声明的两种写法
int(*func(int i))[10];
auto func(int i) -> int(*)[10];

void myFunction(int a, int b = 10) {
    // Function body
}

Record lookup(const Account&);
Record lookup(const Phone&);
Record lookup(const Name&);

// 比较两个string 对象的长度
bool lengthCompare(const string &, const string &);

// pf 指向一个函数，该函数的参数为两个const string的引用
bool (*pf)(const string &, constr string &);

// 可进行以下赋值
pf = lengthCompare;

class Screen {
	friend class WindowMgr;
}

inline Screen &Screen::set(char c) {
    // operation

    // 返回this 指针所指Screen 值，
    return *this;
}

class X {
	int i;
	int j;
public:
	X(int val): i(val), j(i) {}
};

Data val = { "Anna", 1024 };

class Account {
public:
	static double rate() { return interestRate; }
	static void rate(double);
private:
	static constexpr int period = 30; 	// period 是常量表达式
	double daily_tbl[period];
}

cout << unitbuf;

while (begin != v.end()) {
    ++begin;
    beding = v.insert(begin, 42); // 插入新值
    ++begin;
}

// 在vector 上实现的空栈
stack<string, vector<string>> str_stk;
// str_stk2 在vector 上实现，初始化时保存对svec的拷贝
stack<string, vector<string>> str_stk2(svec);

template< class InputIt, class T >
T accumulate(
	InputIt first,
	InputIt last,
	T init
);

template<
    class Category,
    class T,
    class Distance = std::ptrdiff_t,
    class Pointer = T*,
    class Reference = T&
> struct iterator;

// 比较函数, 用来按照长度排序单词
bool isShorter(const string &s1, const string &s2) {
    return s1.size() < s2.size();
}

// 按长度由短至长排序words
sort(words.begin(), words.end(), isShorter);

// lambda 模版
[capture list](parameter list) -> return type {function body}

// lambda 初探
stable_sort(
    words.begin,
    words.end,
    [](const string &a, const string &b) {
        return a.size() < b.size();
    }
)

// 获取一个迭代器，指向第一个满足size()>=sz的元素
auto wc = find_if(
	words.begin(),
	words.end(),
	[sz](const string &a) {
        return a.size() >= sz;
    }
)

// string 到size_t的空map
map<string, size_t> word_count;
set<string> exclude = {"The", "But", "And", "Or"}

string word;
while (cin >> word) {
    // 只统计不在exclude中间的词
    if (exclude.find(word) == exclude.end())
        ++word_count[word];
}

bool compareIsbn(const Sales_data &lhs, const &Sales_data &rhs) {
    return lhs.isbn() < rhs.isbn;
}

multiset<Sales_data, decltype(compareIsbn)*>bookstore(compareIsbn);

pair<string, string> anon {"james", "joyce"};
cout << anon.first << endl;

map<string, size_t> word_count;
string word;
while (cin >> word) {
    // 插入一个元素，关键字等于word，值为1
    // 若word已在word_count中，insert什么也不会做
    auto ret = word_count.insert({word, 1});
    if (!ret.second) {
        ++ret.first->second;
    }
}

// 参考上图中的操作方式
// 也可写为
// auto p1 = make_shared<int>(42);
shared_ptr<string> p1 = make_shared<int>(42);
if (p1 && p1->empty()) {
    *p1 = "hi";
}

// 也可以显式的通过new 创建智能指针
shared_ptr<int>(new int(20));

auto p = make_shared<int>(60);
weak_ptr<int> wp(p);

// lock 返回shared pt, 保证在调用链路中不被回收
if (shared_ptr<int> np = wp.lock()) {

}

typedef int arrT[42];   // arrT 为42个数组的类型别名
int *p = new arrT;		// 分配一个42个数组； p 指向第一个元素
delete [] p;			// 回收第一个

allocator<string> alloc;
auto const p = alloc.allocate(n);
auto q = p;
alloc.construct(q++, "hi"); // now *q is "hi"

class Sales_data {
public:
	Sales_data(const Sales_data&);
private:
	std::string bookNo;
	int units_sold = 0;
}

// 外部实现
Sales_data::Sales_data(cibsr Sales_data &orig):
		bookNo(orig.bookNo),
        units_sold(orig.units_sold) { }

// 等同于Sales拷贝赋值运算
Sales_data&
Sales_data::operator=(const Sales_data &rhs)
{
    bookNo = rhs.bookNo;
    units_sold = rhs.units_sold;
    revenue = rhs.revenue;
    return *this;
}

class Sales_data {
public:
	// 成员会被自动销毁
	～Sales_data() { }
}

struct NoDtor {
	NoDtor() = default;  	// 使用合成默认构造函数
	NoDtor(const NoDtor&) = delete; // 表示不希望支持拷贝
    ～NoDtor() = delete;	// 进制销毁NoDtor 类型对象.
}

class HasPtr {
public:
	HasPtr(const std::string &s = std::string()):
		ps(new std::string(s)), i(0) { }
	// 对ps指向的string，每个HasPtr对象都有自己的拷贝
	HasPtr(const HasPtr &p):
    	ps(new std::string(*p.ps)）, i(p.i) { }
	HasPtr& HasPtr::operator=(const HasPtr &rhs);
	~HasPtr() { delete ps; }
}

HasPtr& HasPtr::operator=(const HasPtr &rhs)
{
    auto newp = new string(*rhs.ps);
    delete ps;

    ps = newp;
    i = rhs.i;
    return *this;
}

class HasPtr {
public:
	HasPtr(const std::string &s = std::string()):
		ps(new std::string(s)), i(0), use(new std::size_t(1)) { }
	// 拷贝三个数据成员，并递增计数器
	HasPtr(const HasPtr &p):
    	ps(new std::string(*p.ps)）, i(p.i), use(p.use) { ++*use; }
	HasPtr& operator=(const HasPtr&);
	~HasPtr;
}

HasPtr::~HasPtr() {
	if (--*use == 0) {
    	delete ps;
    	delete use;
    }
}

HasPtr& HasPtr::operator=(const HasPtr &rhs) {
	++*rhs.use;
	if (--*use == 0) {
		delete ps;
    	delete use;
    }
	ps = rhs.ps;
	i = rhs.i;
    use = rhs.use;
	return *this;
}

#ifndef STRVEC_H
#define STRVEC_H

#include <iostream>
#include <memory>
#include <utility>

// simplified implementation of the memory allocation strategy for a vector-like class
class StrVec {
public:
	// copy control members
    StrVec():
	  elements(0), first_free(0), cap(0) { }

	StrVec(const StrVec&);            // copy constructor
	StrVec &operator=(const StrVec&); // copy assignment

	~StrVec();                            // destructor

	// additional constructor
	StrVec(const std::string*, const std::string*);

    void push_back(const std::string&);  // copy the element

	// add elements
    size_t size() const { return first_free - elements; }
    size_t capacity() const { return cap - elements; }

	// iterator interface
	std::string *begin() const { return elements; }
	std::string *end() const { return first_free; }

	// operator functions covered in chapter 14
	std::string& operator[](std::size_t n)
		{ return elements[n]; }

	const std::string& operator[](std::size_t n) const
		{ return elements[n]; }

private:
    static std::allocator<std::string> alloc; // allocates the elements

	// utility functions:
	//  used by members that add elements to the StrVec
	void chk_n_alloc()
		{ if (size() == capacity()) reallocate(); }
    // used by the copy constructor, assignment operator, and destructor
	std::pair<std::string*, std::string*> alloc_n_copy
	    (const std::string*, const std::string*);
	void free();             // destroy the elements and free the space
    void reallocate();       // get more space and copy the existing elements
    std::string *elements;   // pointer to the first element in the array
    std::string *first_free; // pointer to the first free element in the array
    std::string *cap;        // pointer to one past the end of the array
};

#include <algorithm>

inline
StrVec::~StrVec() { free(); }

inline
std::pair<std::string*, std::string*>
StrVec::alloc_n_copy(const std::string *b, const std::string *e)
{
	// allocate space to hold as many elements as are in the range
	std::string *data = alloc.allocate(e - b);

	// initialize and return a pair constructed from data and
	// the value returned by uninitialized_copy
	return std::make_pair(data, uninitialized_copy(b, e, data));
}

inline
StrVec::StrVec(const StrVec &s)
{
	// call alloc_n_copy to allocate exactly as many elements as in s
	std::pair<std::string*, std::string*> newdata =
							alloc_n_copy(s.begin(), s.end());
	elements = newdata.first;
	first_free = cap = newdata.second;
}

inline
void StrVec::free()
{
    // may not pass deallocate a 0 pointer; if elements is 0, there's no work to do
	if (elements) {
    	// destroy the old elements in reverse order
		for (std::string *p = first_free; p != elements; /* empty */)
			alloc.destroy(--p);
		alloc.deallocate(elements, cap - elements);
	}
}

inline
StrVec &StrVec::operator=(const StrVec &rhs)
{
	// call alloc_n_copy to allocate exactly as many elements as in rhs
	std::pair<std::string*, std::string*> data =
							alloc_n_copy(rhs.begin(), rhs.end());
	free();
	elements = data.first;
	first_free = cap = data.second;
	return *this;
}

inline
void StrVec::reallocate()
{
    // we'll allocate space for twice as many elements as the current size
    size_t newcapacity = size() ? 2 * size() : 1;

	// allocate new memory
	std::string *newdata = alloc.allocate(newcapacity);

	// copy the data from the old memory to the new
	std::string *dest = newdata;  // points to the next free position in the new array
    std::string *elem = elements; // points to the next element in the old array
	for (size_t i = 0; i != size(); ++i)
		alloc.construct(dest++, *elem++);

	free();  // free the old space once we've moved the elements

    // update our data structure to point to the new elements
    elements = newdata;
    first_free = dest;
    cap = elements + newcapacity;
}

inline
StrVec::StrVec(const std::string *b, const std::string *e)
{
	// call alloc_n_copy to allocate exactly as many elements as in il
	std::pair<std::string*, std::string*> newdata = alloc_n_copy(b, e);
	elements = newdata.first;
	first_free = cap = newdata.second;
}

inline
void StrVec::push_back(const std::string& s)
{
    chk_n_alloc(); // ensure that there is room for another element
    // construct a copy of s in the element to which first_free points
    alloc.construct(first_free++, s);
}

#endif

int &&rr1 = 42;			     // correct, 42 为右值引用,（运算结果）
int &&rr2 = rr1;			 // wrong, rr1 为左值, (变量为左值，毕竟变量离开作用域时才会被销毁）
int &&rr3 = std::move(rr1);  // ok "std::move 可接受左值对象，并且显式的将它转换成为右值."

StrVec::StrVec(StrVec &&s) noexcept:
elements(s.elements), first_free(s.first_free), cap(s.cap) {
    s.element = s.first_free = s.cap = nullptr;
}

String s1("Hello");
String s2 = std::move(s1); // Move constructor is called

String s1("Hello");
String s2;
s2 = std::move(s1); // Move assignment operator is called

class String {
    char* data;
    size_t len;
public:
    // Move assignment operator
	// 移动操作通常不会抛出任何异常, 当便携一个不抛出异常的移动操作时，
	// 我们应该将此事通知给标准库.
    String& operator=(String&& other) noexcept {
        if (this != &other) {
            delete[] data; // Free existing resource

            // Steal resources from other
            data = other.data;
            len = other.len;

            // Reset other
            other.data = nullptr;
            other.len = 0;
        }
        return *this;
    }

    // Other members...
};

Derived derivedObj;
Base* basePtr = &derivedObj;

#include <iostream>

class Base {
public:
    virtual void print() {
        std::cout << "This is the base class" << std::endl;
    }
};

class Derived : public Base {
public:
    void print() override {
        std::cout << "This is the derived class" << std::endl;
    }
};

int main() {
    Base* basePtr = new Derived();  // 基类指针指向派生类对象

    // 使用 dynamic_cast 进行向下转型
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);

    if (derivedPtr) {
        // 转型成功，可以访问派生类的成员和函数
        derivedPtr->print();
    } else {
        // 转型失败，基类对象不是派生类的对象
        std::cout << "Cannot convert from Base to Derived" << std::endl;
    }

    delete basePtr;

    return 0;
}

class Base {
public:
    virtual void pureVirtualFunction() = 0;
};

class Base {
public:
    Base(int x) {
        // 构造函数逻辑
    }
};

class Derived : public Base {
public:
    Derived(int x, int y) : Base(x) {
        // 派生类构造函数的逻辑
    }
};

class Derived : public Base {
public:
    Derived(const Derived& other) : Base(other), derived_member(other.derived_member) {
        // Copy construct other members...
    }
    // ...
};

class Derived : public Base {
public:
    Derived& operator=(const Derived& other) {
        if (this != &other) {
            Base::operator=(other);
            derived_member = other.derived_member;
            // Copy other members...
        }
        return *this;
    }
    // ...
};

class Derived : public Base {
public:
    Derived& operator=(Derived&& other) noexcept {
        if (this != &other) {
            Base::operator=(std::move(other));
            derived_member = std::move(other.derived_member);
            // Move other members...
        }
        return *this;
    }
    // ...
};

// 模版type 可支持默认函数实参
template <typename T, typename U = int>
class Pair {
    T first;
    U second;

public:
    Pair(T a, U b) {
        first = a;
        second = b;
    }

    T getFirst() {
        return first;
    }

    U getSecond() {
        return second;
    }
};

template <typename T>
T add(T a, T b) {
    return a + b;
}

template <typename T, typename U>
class Pair {
    T first;
    U second;

public:
    // ....
	// 成员模版 ～
    template <typename V>
    void modifyFirst(V value) {
        first = value;
    }
};

// mytemplate.hpp

template <typename T>
T add(T a, T b) {
    return a + b;
}

// main.cpp

#include <iostream>

// 声明模板实例化定义位于其他文件中
extern template int add(int a, int b);

int main() {
    int result = add(5, 10);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

template <typename T>
typename std::remove_reference<T>::type&& move(T&& t) noexcept {
    return static_cast<typename std::remove_reference<T>::type&&>(t);
}

template <typename T>
void wrapper(T&& arg) {
    some_function(std::forward<T>(arg)); // Perfectly forward arg to some_function
}

#include <iostream>

// 递归终止条件：当没有剩余参数时打印换行符并返回
void print() {
    std::cout << std::endl;
}

// 打印第一个参数，然后递归调用print函数处理剩余参数
template<typename T, typename... Args>
void print(const T& first, const Args&... args) {
    std::cout << first << " ";
    print(args...);
}

int main() {
    print(1, 2, 3); // 打印：1 2 3

    print("Hello", 4, 5.6, "World"); // 打印：Hello 4 5.6 World

    return 0;
}