c++概览:抽象机制

• 简化复数类

#include<iostream>
using namespace std;
class complex {
	double re, im;
public:
	complex(double r,double i):re{r},im{i}{}
	complex(double r):re{r},im{0}{}
	complex():re{0},im{0}{}

	double real()const { return re; }
	void real(double r) { re = r; }
	double imag()const { return im; }
	void imag(double i) { im = i; }

	complex& operator +=(complex z) { re += z.re; im += z.im; return *this; }
	complex& operator -=(complex z) { re -= z.re; im -= z.im; return *this; }
};
//操作符与类的定义分离开来
complex operator+(complex a, complex b) { return a += b; }
complex operator-(complex a, complex b) { return a -= b; }
complex operator-(complex a) { return { -a.real(),-a.imag() }; }
bool operator==(complex a, complex b) { return a.real() == b.real()&&a.imag() == b.imag(); }
bool operator!=(complex a, complex b) { return !(a == b); }
int main() {
	complex a{ 2.3 };
	complex b{ 1,2.2 };
	if (b != a)
		b += a;
	cout << b.real();
}

• 抽象类,列表初始化,分离编译

main
#include "pch.h"
#include<iostream>
using namespace std;
int main() {
	Vector v0(1);//size构造函数
	Vector v1{ 1,2,3 };//初始化列表构造函数
	Vector v2{ v1 };//拷贝构造函数
	Vector v3(3);
	v3 = v2;//拷贝赋值运算符
	Vector v4{ move(v3) };//移动构造函数
}

pch.h
#include<initializer_list>
#include<list>
class Vector {
private:
	double * elem;
	int sz;
public:
	Vector(int s);
	Vector(std::initializer_list<double>lst);
	Vector(const Vector& a);
	Vector & operator = (const Vector& a);
	Vector(Vector&& a);
	double & operator [](int i);
	int size()const;
	~Vector();
};

pch.cpp
#include "pch.h"
#include<initializer_list>
#include<algorithm>
#include<iostream>
//构造函数
Vector::Vector(int s) :elem{ new double[s] }, sz{ s }{
	std::cout << "constructor1\n";
	for (int i = 0; i < s; i++) elem[i] = 0;
}
//构造函数
Vector::Vector(std::initializer_list<double>lst) : elem{ new double[lst.size()] }, sz{ int(lst.size()) }{
	std::cout << "constructor2\n";
	std::copy(lst.begin(), lst.end(), elem);
}

//拷贝构造函数与拷贝赋值运算符
Vector::Vector(const Vector& a) : elem{ new double[a.sz] }, sz{ a.sz }{
	std::cout << "constructor3\n";
	for (int i = 0; i < a.sz; i++) elem[i] = a.elem[i];
}
Vector & Vector::operator=(const Vector& a) {
	std::cout << "constructor4\n";
	delete[] elem;
	elem = new double[a.sz];
	for (int i = 0; i < a.sz; i++) elem[i] = a.elem[i];
	sz = a.sz;
	return *this;
}

//移动构造函数
Vector::Vector(Vector&& a) :elem{ a.elem }, sz{ a.sz }{
	std::cout << "constructor5\n";
	a.elem = nullptr;
	a.sz = 0;
}
//成员函数
double & Vector::operator [](int i) { return elem[i]; }
int Vector::size()const { return sz; }

//析构函数
Vector::~Vector() { delete[] elem; std::cout << "destrcutor\n"; }

• const在前与在后的区别

//const在后表示一个const成员函数,在函数内不允许修改函数的成员变量,不允许修改re和im
double real()const { return re; }

//const在前表示限定返回值,返回值不允许出现在等号的左边
const double real(){ return re; }

• 自定义函数范围for循环,定义begin(),end()函数

#include<iostream>
using namespace std;
template<typename T>
class Vector{
private:
    T * data;
    int sz;
public:
    Vector(int size);
    ~Vector(){delete[] data;}
    T & operator[](int i)const;
    T * begin(){
        return &data[0];
    }
    T * end(){
        return &data[0]+sz;
    }
};
template<typename T>
Vector<T>::Vector(int size){
    if(size<0) cout<<"error\n";
    data = new T[size];
    sz = size;
}
template<typename T>
T & Vector<T>::operator[](int i)const{
    return data[i];
}
int main(){
    Vector<string>vs(17);
    vs[0] = "hello";
    for(auto & tmp : vs){
        cout<<tmp<<" ";
    }
}