一、引言

“知所从来，方知其往。”只有了解一个物体的构造才能更好的使用它。正所谓“不入虎穴，焉得虎子。”那我们学会使用一个类了，可不可以建造一个简易的类和对象出来呢？答案显而易见。因为这是C++的内容，所以我们用C++更能贴近底层。

二、友元函数与内部类

“有朋自远方来，不亦乐乎。”既然是朋友从远道来，按照传统礼仪，一定是主随客便。身为客人自然可以提出自己的生活要求让主人尽量满足，主人为了以尽主客之宜自然会尽量满足。友元函数、友元类就像朋友在主人家做客一样。正常来说类中的私有是无法在类域外访问的，但是在友元函数、友元类中这并不是什么难事。友元函数、友元类在其他类域中申明，可以通过接受类对象访问类的私有。友元函数和友元类的关键字是friend。相当于主人家将自己陈年收藏的美酒（私有）拿出款待客人。内部类就更好理解了，内部类就好比外部类的孩子，孩子是未来家庭的当家人，自然可以对自己家陈年珍藏的宝物做主。

#include<iostream>
using namespace std;

//友元类的声明所在的类，一定要在友元类的上面，或是声明在所在类的上方
//因为友元类访问私有需要用到已定义的类
//而编译是从上至下进行的
//造成了编译错误
//就像客人突然到访，主人没有做好准备。
class A
{
public:
    //友元类申明
	friend class B;
    class C
    {
    public:
	    void fun(A& aa)
	    {
            std::cout << "inner class" << std::endl;
		    std::cout << aa.a << " ";
            std::cout << std::endl;
	    }
    };
private:
	int a = 11;
};

//友元类
struct B
{
	void func(A& aa)
	{
        std::cout << "friend class or friend function" << std::endl;
		std::cout << aa.a;
        std::cout << std::endl;
	}
};

int main()
{
	A aa;
	B b;
	b.func(aa);

	return 0;
}

三、        string的的模拟实现

三、一        string的构造函数、默认构造、拷贝构造、析构函数

我们由浅入深，从string的构造函数、默认构造、拷贝构造、析构函数开始。存储字符肯定是要用到字符类型(char)的变量，除此之外我们要在字符数组的基础上进行管理，那我们就必须在内存中创建属于我们自己的一块内存。那我们就要用到C++中的关键字new和delete，由于我们申请的内存比较小，就不进行抛异常(内存)的检查了。关于申请多大的内存，又怎么管理这些内存。我们需要定义一个_size(字符串的长度)和一个_capacity(字符数组的大小)。因为如果一改变字符串长度，字符数组的大小就跟着扩容、缩容，非常浪费效率，还很麻烦。

class string
{
private:
    //在类和对象中的变量前加上一个下划线(_)，代表这是变量，
    //让程序可读性更强一些。
    //加上一些缺省参数，减少错误的访问。
    char* _str = nullptr;
    size_t _size = 0;
    size_t _capacity = 0;
}

接着我们来写默认构造，我们创建类对象时可能会直接对类对象进行初始化，所以我们可以在默认构造函数里加入一个参数来初始化，又因为默认构造函数可以不需要参数创建类对象，所以我们将这个默认构造函数中的参数中加入一个缺省参数。

//定义一定是在类中定义或是在类中声明类外定义
//这里把它单独拿出来为了好看一些。
string(const char* str = "")
//这里的缺省值空字符串代表的就是字符末尾'\0'
//毕竟C语言是用'\0'来作为字符串末尾的
//C++要兼容C语言，自然要对C语言内容有所保留。
{
   	size_t len = strlen(s);
	_str = new char[len + 1];
	strcpy(_str,s);
	_size = _capacity = len;
}

string的拷贝构造和operator = 就简单多了。只需要获取字符长度，开好空间，在做好复制粘贴。operator = 也是一样。

string(const string& s)
{
	size_t len = strlen(s._str);
    //_size和_capacity不将'\0'计算在内
    //毕竟strlen()也不计算'\0'。
    //计算有效字符。
    //所以len加一是多一个空间存放'\0'
	_str = new char[len + 1];
    strcpy(_str,s._str);
	_size = _capacity = len;
}

接下来就是析构，析构就非常简单了直接new，然后再对_size和_capacity进行归零就行了。

~string()
{
    //delete后加上[]是因为_str是一个数组，不是一个变量
    //我们定义数组时也会加[]
	delete[] _str;
	_size = _capacity = 0;
}

三、二        string中的reserve()

reserve()是存储的意思。因为每次申请空间都要改变_capacity。所以我们自己单独写一个申请内存的函数。

void reserve(size_t n)
{
	if (n > _capacity)
	{
		char* tmp = new char[n + 1];
		strcpy(tmp,_str);
		_capacity = n;
		delete[] _str;
		_str = tmp;
	}
}

三、三        string中的c_str()

  string中的c_str()函数返回一个记载私有变量_str中字符的字符串。因为类对象可能为const类型，加上返回的字符串无需改值，就前后各加了一个const。

	const char* string:: c_str()const
	{
		return _str;
	}

三、四        string中的insert()和erase()函数

insert()insert()和erase()函数分别是在指定位置插入字符和删除字符函数。删除函数就比较好理解，将指定位置之后的字符向前移动一个位置，对指定位置的字符进行覆盖。指定位置插入字符则与之相反，指定位置的字符向后移动一个位置，空出来的位置就是指定位置。同时还涉及到迭代器失效。我们可以设置在insert()函数中一个返回插入位置的迭代器，也可以直接返回对string对象的引用（因为引用更简单，所以我们偷点懒），在erase()函数中放入一个返回删除位置的下一个位置。至于造成迭代器失效的原因则是扩容和缩容导致的插入、删除位置的变化与原先迭代器指向的位置不符。

// 在pos位置上插入字符c/字符串str，并返回该字符的位置

string& insert(size_t pos, char c)
{
	assert(pos < _size);
	_str[pos] = c;
	return (*this);
}

string& insert(size_t pos, const char* str)
{
	size_t len = strlen(str);

	if (_size + len > _capacity)
	{
		reserve(_size + len > 2 * _capacity ? _size + len : _capacity);
	}
	
	for (int i = 0; i < len; i++)
	{
		_str[pos + i] = str[i];
	}

	_size += len;
	_str[_size] = '\0';

	return (*this);
}

string& erase(size_t pos, size_t len)
{
	for (int i = pos + len; i <= _size; i++)
	{
		_str[i - len] = _str[i];
	}
	_size -= len;
	return (*this);
}

string中的push_back()函数也可以用insert()函数来嵌套实现。

三、五        string中的size()和capacity()函数

返回_size和_capacity的值。

size_t size()
{
    return _size;
}

size_t capacity()
{
    return _capacity;
}

三、六        string中的operator []         和        operator        +=

operator []是通过下标访问，需要用到引用，当然也可以用指针。operator        +=则是在字符串末尾末尾的添加字符和字符串，也可以用iinsert()嵌套调用。

string& operator+=(char c)
{
	if (_size == _capacity)
	{
		reserve(2 * _capacity);
	}
	_str[_size] = c;
	++_size;
	return (*this);
}

string& operator+=(const char* str)
{
	(*this).insert(_size,str);
	return (*this);
}

char& operator[](size_t index)
{
	assert(index < _size);
	return _str[index];
}

三、七        string中的find()函数和clear()函数

find()是查找字符和字符串，查找字符只需遍历一遍_str，一个一个字符地进行比较。如果是字符串，由于KMP算法比较复杂，所以我们建议用<string.h>中的中的strstr()函数。至于clear()函数就更简单了。直接改变_size，将_str的第一个位置赋值为'\0'。

size_t find(char c, size_t pos) const
{
	for (int i = pos; i < _size; i++)
	{
		if (_str[i] == c)
		{
			return i;
		}
	}
	return npos;
}

// 返回子串s在string中第一次出现的位置

size_t find(const char* s, size_t pos) const
{
	char* tmp = strstr(_str + pos, s);
	return tmp - _str;
}

void clear()
{
	_str[0] = '\0';
	_size = 0;
}

三、八       string中的operator        <<        和        operator        >>

C++规定流插入、流提取运算符重载时需为全局函数那我们就可以在string中声明友元函数访问string中的私有变量。

std::ostream& operator << (std::ostream& _cout, const word::string& s)
{
    //范围for()通过类中的begin()和end()函数的返回值访问
    //将s中的字符插入在流中
	for (auto& ch : s)
	{
	   _cout << ch;
   	}
	return _cout;
}

std::istream& operator >> (std::istream& _cin, word::string& s)
{
    //在提取之前先清除一下s中的所有字符
    //用一个字符数组充当缓冲区，减少扩容次数，增加效率
	s.clear();
	const int N = 255;
	char buf[N + 1] = { 0 };
	int i = 0;

	char ch = '\0';

    //因为输入输出默认用空格和换行做分隔符。
	while (ch != ' ' && ch != '\n')
	{
		// get()函数一个字符一个字符地去读
		ch = _cin.get();
		buf[i++] = ch;
		if (i == N - 1)
		{
			buf[i] = '\0';
			i = 0;
			s += buf;
		}
	}
	if (i > 0)
	{
		buf[i] = '\0';
		s += buf;
	}
	return _cin;
}

三、九        string中的begin()和end()

这两个函数都是返回迭代器(iterator,就相当于字符地址，为了更加简单就用字符指针)的函数。begin()是返回string中_str的起始位置，end()是返回string中_str的末尾位置的下一个地址。

typedef char* iterator;
typedef const char* const_iterator;

iterator begin()
{
    //数组名就是是首元素的地址。
    return _str;
}

iterator end()
{
    return _str + _size;
}

const_iterator begin() const
{
    return _str;
}

const_iterator end() const
{
    return _str + _size;
}