C++面试常用代码

文|Seraph

01 | 排序

1. 快排

void quickSort(vector<int> &num, int l, int r) {
    if (l >= r)     //先检查左右条件
        return;
    int i = l, j = r, x = num[l];
    while (i < j) {
        while (i < j && num[j] >= x)//从右向左找到第一个小于x的
            j--;
        if (i < j)
            num[i++] = num[j];//填坑之后i++
        while (i < j && num[i] <= x)//从左向右找第一个大于x的数
            i++;
        if (i < j)
            num[j--] = num[i];
    }
    num[i] = x;     //把最开始取出来的x放到i处
    quickSort(num, l, i - 1);//以i为中间值，分左右两部分递归调用
    quickSort(num, i + 1, r);
}

02 | 查找

1. 二分查找

• 迭代版本

template<class T>  
int Binary_Search(T *x, int N, T keyword)  
{  
    int low = 0, high = N-1,mid;  
    while(low <= high)  
    {  
        mid = (low + high)/2;  
        if(x[mid] == keyword)  
            return mid;  
        if(x[mid] < keyword)  
            low = mid + 1;  
         else  
            high = mid -1;  

    }  
    return -1;  
}  

• 递归版本

/*折半查找，递归实现*/  
int Binary_Search2(int *a, int low, int high, int key)  
{  
     if(low > hign) 
          return -1;
     int mid = (low + high) / 2;  
     if(a[mid] == key)  
          return mid;  
     if(a[mid] > key)  
          return Binary_Search2(a, low, mid-1, key);     //有没有return都可以。  
     else  
          return Binary_Search2(a, mid+1, high, key);     //有没有return都可以。  
} 

03 | 类

1. 链表

1.1 单链表

#include <iostream>
#include <string>

using namespace std;

//链表节点
template<typename T>
struct ListNode
{
    T data;
    ListNode<T> *next;
};

//单向链表 -- 采用类模板
//单链表操作类模板
template <typename T>
class LinkList
{
public:
    LinkList();
    LinkList(T elem);
    LinkList(int n, T elem);
    ~LinkList();
    void ClearList() const;
    bool Empty() const;
    int Length() const;
    T GetElem(int n) const;
    int LocateElem(T elem) const;
    bool Insert(int n, T elem);
    bool Delete(int n);
    void Displasy();
    void Remove(T elem);
private:
    ListNode<T> *m_head;
};

template <typename T>
LinkList<T>::LinkList() 
{
    //创建头节点
    m_head = new ListNode<T>;
    if (nullptr == m_head)
    {
        cout << "动态申请头节点内存失败" << endl;
        return;
    }

    m_head->next = nullptr;
}

template <typename T>
LinkList<T>::LinkList(T elem) :LinkList()
{
    Insert(1, elem);
}

template <typename T>
LinkList<T>::LinkList(int n, T elem) :LinkList()
{
    for (int i = 0; i < n; ++i)
    {
        Insert(i, elem);
    }
}

template <typename T>
LinkList<T>::~LinkList()
{
    ClearList();    //置为空白
    delete m_head;  //释放头节点
}

template <typename T>
void LinkList<T>::ClearList() const     //常成员函数 不改变对象的值
{
    ListNode<T> *temp, *p = m_head->next;

    while (p != nullptr)        //删除头节点以后的所有节点
    {
        temp = p->next;
        delete p;           //要释放动态内存
        p = temp;
    }

    m_head->next = nullptr;
}

template <typename T>
bool LinkList<T>::Empty() const
{
    //如果头节点的下一个节点为空，则该链表为空
    return nullptr == m_head->next;
}

template <typename T>
int LinkList<T>::Length() const
{
    int count = 0;
    ListNode<T> *ptemp = m_head->next;

    while (ptemp != nullptr)
    {
        count++;
        ptemp = ptemp->next;
    }

    return count;
}

template <typename T>
T LinkList<T>::GetElem(int n) const
{
    ListNode<T> *ptemp = m_head->next;

    if (n <= Length())
    {
        for (int i = 1; i < n; ++i)
        {
            ptemp = ptemp->next;
        }
    }
    else
    {
        cout << "out of ranger" << endl;
        return false;
    }

    return ptemp->data;
}

template <typename T>
int LinkList<T>::LocateElem(T data) const
{
    size_t location = 0;
    ListNode<T> *ptemp = m_head->next;

    while (ptemp != nullptr)
    {
        ++location;
        if (ptemp->data == data)            //注意 该类型必须支持 == 操作符，如果不支持需要进行运算符重载
        {
            return location;
        }

        ptemp = ptemp->next;
    }

    return 0;       //返回0表示未找到
}

template <typename T>
bool LinkList<T>::Insert(int n, T elem)
{
    ListNode<T> *ptemp = m_head;

    if (n-1 <= Length())
    {
        for (int i = 0; i < n - 1; ++i)
        {
            ptemp = ptemp->next;
        }

        //先生成一个新的节点
        ListNode<T> *newnode = new ListNode < T >;
        if (nullptr == newnode)
        {
            cout << "申请空间失败" << endl;
            return false;
        }

        newnode->data = elem;       //如果数据类型不是基本数据类型，即不支持 = 操作符，需要重载 = 操作符
        newnode->next = ptemp->next;
        ptemp->next = newnode;

        return true;
    }
    else
    {
        cout << "out of range" << endl;
        return false;
    }
}

template <typename T>
bool LinkList<T>::Delete(int n)
{
    ListNode<T> *ptemp = m_head;

    if (n <= Length())
    {
        for (int i = 0; i < n - 1; ++i)
        {
            ptemp = ptemp->next;
        }

        ListNode<T> *t = ptemp->next;       //指向待删除的节点

        ptemp->next = ptemp->next->next;        //将待删除节点的上一节点指向待删除节点的下一节点
        delete t;       //释放删除节点的内存

        return true;
    }
    else
    {
        cout << "out of range" << endl;
        return false;
    }
}

template <typename T>
void LinkList<T>::Displasy()
{
    ListNode<T> *ptemp = m_head->next;

    while (ptemp != nullptr)
    {
        cout << ptemp->data << endl;
        ptemp = ptemp->next;
    }
}

template <typename T>
void LinkList<T>::Remove(T elem)
{
    ListNode<T> *ptemp = m_head;

    while (ptemp->next != nullptr)
    {
        if (ptemp->next->data == elem)          //找到与要删除的节点相同
        {
            ListNode<T> *t = ptemp->next;       //指向待删除的节点
            ptemp->next = ptemp->next->next;        //将待删除节点的上一节点指向待删除节点的下一节点
            delete t;       //释放删除节点的内存
        }
        else        //这里需要注意一下：如果删除了那么它的下一节点是新的节点需要重现判断，所以不需要移动
        {
            ptemp = ptemp->next;
        }

    }
}

struct Data
{
    int id;
    string name;
};
//由于使用的是结构体，所以对于一些运算符需要进行重载
ostream &operator << (ostream &os, const Data &data)
{
    os << data.id << "  " << data.name;
    return os;
}

bool operator==(const Data &data1, const Data &data2)
{
    //按照ID进行比较
    return data1.id == data2.id;
}

1.2 双向链表

#include <iostream>

template <class T>
class Node
{
public:
    Node<T> *next;
    Node<T> *prev;
    T data;
};

template <class T>
class List
{
public:
    List();//默认构造函数
    List(const List& ln);//拷贝构造函数
    ~List();//析构函数
    void add(T e);//向链表添加数据
    void ascSort();//升序排序
    void remove(T index);//移除某个结点
    T find(int index);//查找结点
    bool isEmpty();//判断是否为空
    int size();//链表长度
    void show();//显示链表
    void resShow();//链表反向显示
    void removeAll();//删除全部结点
private:
    Node<T> *head;
    Node<T> *tail;
    int length;
};
 
//
//默认构造函数
template <typename T>
List<T>::List()
{
    head = new Node<T>;
    tail = new Node<T>;
    head->next = tail;
    head->prev = nullptr;
    tail->next = nullptr;
    tail->prev = head;
    length = 0;
}
//拷贝构造函数
template <typename T>
List<T>::List(const List &ln)
{
    head = new Node<T>;
    head->prev = nullptr;
    tail = new Node<T>;
    head->next = tail;
    tail->prev = head;
    length = 0;
    Node<T>* temp = ln.head;
    while(temp->next != ln.tail)
    {
        temp = temp->next;
        tail->data = temp->data;
        Node<T> *p = new Node<T>;
        p->prev = tail;
        tail->next = p;
        tail = p;
        length++;
    }
    tail->next = nullptr;
}
//向链表添加数据
template <typename T>
void List<T>::add(T e)
{
    Node<T>* temp = this->tail;
    tail->data = e;
    tail->next = new Node<T>;
    Node<T> *p = tail;
    tail = tail->next;
    tail->prev = p;
    tail->next = nullptr;
    length++;
}
//查找结点
template <typename T>
T List<T>::find(int index)
{
    if(length == 0)
    {
        std::cout << "List is empty";
        return NULL;
    }
    if(index >= length)
    {
        std::cout << "Out of bounds";
        return NULL;
    }
    int x = 0;
    T data;
    Node<T> *p;
    if(x < length/2)
    {
        p = head->next;
        while (p->next != nullptr && x++ != index)
        {
            p=p->next;
        }
    } else{
        p = tail->prev;
        while(p->prev != nullptr && x++ != index)
        {
            p = p->prev;
        }
    }
    return p->data;
}
//删除结点
template <typename T>
void List<T>::remove(T index)
{
    if(length == 0)
    {
        std::cout << "List is empty";
        return ;
    }
    Node<T> *p = head;
    while(p->next!=nullptr)
    {
        p = p->next;
        if(p->data == index)
        {
            Node<T> *temp = p->prev;
            temp->next = p->next;
            p->next->prev = temp;
            delete p;
            length--;
            return ;
        }
    }
}
//删除所有结点
template <typename T>
void List<T>::removeAll()
{
    if(length == 0)
    {
        return ;
    }
    Node<T> *p = head->next;
    while(p != tail)
    {
        Node<T>* temp = p;
        p = p->next;
        delete temp;
    }
    head->next = tail;
    tail->prev = head;
    length = 0;
}
//升序排序
template <typename T>
void List<T>::ascSort()
{
    if(length <= 1) return;
    Node<T> *p = head->next;
    for (int i = 0; i < length-1; i++)
    {
        Node<T> *q = p->next;
        for (int j = i+1; j < length; j++)
        {
            if(p->data > q->data)
            {
                T temp = q->data;
                q->data = p->data;
                p->data = temp;
            }
            q=q->next;
        }
        p = p->next;
    }
}
//判断是否为空
template <typename T>
bool List<T>::isEmpty()
{
    if(length == 0)
    {
        return true;
    } else {
        return false;
    }
}
//链表长度
template <typename T>
int List<T>::size()
{
    return length;
}
//输出链表
template <typename T>
void List<T>::show()
{
    if(length == 0)
    {
        std::cout << "List is empty" << std::endl;
        return;
    }
    Node<T> *p = head->next;
    while (p != tail)
    {
        std::cout << p->data << " ";
        p = p->next;
    }
    std::cout << std::endl;
}
//反向输出链表
template <typename T>
void List<T>::resShow()
{
    if(length == 0)return;
    Node<T> *p = tail->prev;
    while (p != head)
    {
        std::cout << p->data << " ";
        p = p->prev;
    }
    std::cout << std::endl;
}
//析构函数
template <typename T>
List<T>::~List()
{
    if(length == 0)
    {
        delete head;
        delete tail;
        head = nullptr;
        tail = nullptr;
        return;
    }
    while(head->next != nullptr)
    {
        Node<T> *temp = head;
        head = head->next;
        delete temp;
    }
    delete head;
    head = nullptr;
}

2. 字符串类

类声明

#pragma once
#include <iostream>
#include <assert.h>
#include <stdarg.h>

class CMyString
{
    friend std::ostream& operator<< (std::ostream&os, CMyString& other);//重载输入
    friend std::istream& operator>> (std::istream&in, CMyString& other);//重载输出

public:
    CMyString(const char* str = NULL);//构造函数兼容默认构造函数
    CMyString(const CMyString& other);//拷贝构造函数
    CMyString& operator=(const CMyString& other);//重载=
    CMyString operator+(const CMyString& other);//重载+
    CMyString operator+=(const CMyString& other);//重载+=
    ~CMyString();//析构函数
    size_t GetLength();//获取字符串长度
    bool operator==(const CMyString& other);//判断两个字符串是否相等
    char& operator[](unsigned int nIndex);//重载[]
    const char* GetC_Str() const;//获取C字符串
    void MakeUpper();//转为大写
    void MakeLower();//转为小写
    bool IsEmpty();//判断字符串是否为空
    void Empty();//清空字符串
    void Format(char* fmt, ...);//格式化字符串
    int CompareNoCase(const CMyString& other);//不区分大小写比较字符串，大于other返回1，小于返回-1，等于返回0
    int CompareNoCase(const char* str);//重载不区分大小写的比较函数
    CMyString LeftSubString(int nCount);//取子串，从左边开始取nCount个字符
    CMyString RightSubString(int nCount);//取子串，从右边往左边数nCount个字符
    CMyString MidSubString(int nFirst, int nCount);//取子串，从nFirst的位置开始，取nCount个字符
    CMyString MidSubString(int nFirst);//重载取子串，从nFirst的位置开始，一直取到最后
    int FindString(const CMyString& other);//查找子串
    int FindString(const char* str);//重载查找子串
    int FindString(const CMyString& other, int nStart);//从nStart位置开始查找子串
    int FindString(const char* str, int nStart);//重载从nStart位置开始查找子串
    int FindChar(char ch);//查找字符
    int FindChar(char ch, int nStart);//从nStart的位置开始查找字符
    void MakeReverse();//字符串逆置
    int Remove(char ch);//删除字符串中所有的指定字符
    int Replace(char chOld, char chNew);//替换字符
    int Replace(char* pOld, char* pNew);//替换字符串
    int Insert(int nIndex, char ch);//在nIndex位置插入一个字符
    int Insert(int nIndex, char* pStr);//在nIndex位置插入一个字符串
    void Sort();//对字符串进行排序
    int ToInt();//把字符串转成int类型

private:
    size_t MyStrlen(const char *pStr);
    char * MyStrcpy(char *dst, const char *src);
    char * MyStrcat(char *dst, const char *src);
    int MyStrcmp(const char* str1, const char* str2);
    char *ReturnUpper(const char* str);
    char *ReturnLower(const char* str);
    char* GetSubstring(const char *strSource, const unsigned int uStartPos, const unsigned int uEndPos);
    int MyStrstr(const char *s1, const char *s2, int nStartPos = 0);
    int MyIsSpace(char ch);
    int MyIsDigit(char ch);
    int MyAtoi(const char* pStr);

private:
    char *m_str;
    size_t m_nLength;
};

类实现

#include "StdAfx.h"
#include "MyString.h"

CMyString::CMyString(const char* str /*= NULL*/)
{
    if (NULL == str)
    {
        m_nLength = 0;
        m_str = new char[1];
        *m_str = '\0';
    }
    else
    {
        m_nLength = MyStrlen(str);
        m_str = new char[m_nLength + 1];
        MyStrcpy(m_str, str);
    }
}

CMyString::CMyString(const CMyString& other)
{
    m_nLength = other.m_nLength;
    m_str = new char[m_nLength + 1];
    MyStrcpy(m_str, other.m_str);
}

CMyString& CMyString::operator=(const CMyString& other)
{
    if (this == &other)
        return *this;

    delete []m_str;
    m_nLength = other.m_nLength;
    m_str = new char[m_nLength + 1];
    MyStrcpy(m_str, other.m_str);
    return *this;
}

CMyString CMyString::operator+(const CMyString& other)
{
    CMyString retStr;
    retStr.m_nLength = m_nLength + other.m_nLength;
    retStr.m_str = new char[retStr.GetLength() + 1];
    MyStrcpy(retStr.m_str, m_str);
    MyStrcat(retStr.m_str, other.m_str);
    return retStr;
}

CMyString CMyString::operator+=(const CMyString& other)
{
    m_nLength += other.m_nLength;
    char *temp = new char[m_nLength + 1];
    MyStrcpy(temp, m_str);
    MyStrcat(temp, other.m_str);
    delete []m_str;
    m_str = temp;
    return *this;
}

CMyString::~CMyString()
{
    delete []m_str;
    m_nLength = 0;
}

size_t CMyString::GetLength()
{
    return m_nLength;
}

bool CMyString::operator==(const CMyString& other)
{
    if (other.m_nLength != m_nLength)
        return false;

    return MyStrcmp(m_str, other.m_str) ? false : true;
}

char& CMyString::operator[](unsigned int nIndex)
{
    assert(nIndex >= 0 && nIndex <= m_nLength - 1);

    return m_str[nIndex];
}

const char* CMyString::GetC_Str() const
{
    return m_str;
}

size_t CMyString::MyStrlen(const char *pStr)
{
    size_t nLen = 0;
    if (NULL == pStr)
        return 0;

    while (*pStr++ != '\0')
        nLen++;

    return nLen;
}

char * CMyString::MyStrcpy(char *dst, const char *src)
{
    if (dst == NULL || src == NULL)
        return NULL;

    if (dst == src)
        return dst;

    char *ret = dst;
    int nLen = MyStrlen(src);
    dst = dst + nLen;
    src = src + nLen;
    int nLoop = nLen + 1;
    while (nLoop--)
    {
        *dst = *src;
        src--;
        dst--;
    }

    return ret;
}

char * CMyString::MyStrcat(char *dst, const char *src)
{
    assert(dst != NULL && src != NULL);
    char *temp = dst;
    while (*temp != '\0')
        temp++;
    while ((*temp++ = *src++) != '\0');

    return dst;
}

void CMyString::MakeUpper()
{
    for (int i = 0; i < m_nLength; i++)
    {
        if (m_str[i] >= 'a' && m_str[i] <= 'z')
        {
            m_str[i] -= 'a' - 'A';
        }
    }
}

void CMyString::MakeLower()
{
    for (int i = 0; i < m_nLength; i++)
    {
        if (m_str[i] >= 'A' && m_str[i] <= 'Z')
        {
            m_str[i] += 'a' - 'A';
        }
    }
}

bool CMyString::IsEmpty()
{
    return 0 == m_nLength;
}

void CMyString::Empty()
{
    delete []m_str;
    m_nLength = 0;
    m_str = new char[1];
    *m_str = '\0';
}

void CMyString::Format(char* fmt, ...)
{
    static const int nBufferSize = 4 * 1024;
    char TmpBuffer[nBufferSize] = {0};
    va_list argList;
    va_start(argList, fmt);
    vsnprintf(TmpBuffer, nBufferSize, fmt, argList);
    va_end(argList);

    delete []m_str;
    m_str = new char[nBufferSize];
    MyStrcpy(m_str, TmpBuffer);
    m_nLength = MyStrlen(m_str);
}

int CMyString::MyStrcmp(const char* str1, const char* str2)
{
    assert(NULL != str1 && NULL != str2);
    while (*str1 && *str2 && (*str1 == *str2))
    {
        str1++;
        str2++;
    }
    return *str1 - *str2;
}

int CMyString::CompareNoCase(const CMyString& other)
{
    char *str1 = ReturnLower(m_str);
    char *str2 = ReturnLower(other.m_str);
    int nRet = MyStrcmp(str1, str2);
    delete []str1;
    delete []str2;
    if (nRet > 0)
        return 1;
    else if (nRet < 0)
        return -1;

    return 0;
}

int CMyString::CompareNoCase(const char* str)
{
    char *str1 = ReturnLower(m_str);
    char *str2 = ReturnLower(str);
    int nRet = MyStrcmp(str1, str2);
    delete []str1;
    delete []str2;
    if (nRet > 0)
        return 1;
    else if (nRet < 0)
        return -1;

    return 0;
}

char * CMyString::ReturnUpper(const char* str)
{
    int nLen = MyStrlen(str);
    char *Temp = new char[nLen + 1];
    MyStrcpy(Temp, str);

    for (int i = 0; i < nLen; i++)
    {
        if (Temp[i] >= 'a' && Temp[i] <= 'z')
        {
            Temp[i] -= 'a' - 'A';
        }
    }
    return Temp;
}

char * CMyString::ReturnLower(const char* str)
{
    int nLen = MyStrlen(str);
    char *Temp = new char[nLen + 1];
    MyStrcpy(Temp, str);

    for (int i = 0; i < nLen; i++)
    {
        if (Temp[i] >= 'a' && Temp[i] <= 'z')
        {
            Temp[i] -= 'a' - 'A';
        }
    }
    return Temp;
}

CMyString CMyString::LeftSubString(int nCount)
{
    if (nCount < 0)
        nCount = 0;

    if (nCount >= m_nLength)
        return *this;


    char *pTemp = GetSubstring(m_str, 0, nCount - 1);
    CMyString strTemp(pTemp);
    delete []pTemp;
    return strTemp;
}

CMyString CMyString::RightSubString(int nCount)
{
    if (nCount < 0)
        nCount = 0;

    if (nCount >= m_nLength)
        return *this;

    char *pTemp = GetSubstring(m_str, m_nLength - nCount, m_nLength - 1);
    CMyString strTemp(pTemp);
    delete []pTemp;
    return strTemp;
}

CMyString CMyString::MidSubString(int nFirst, int nCount)
{
    if (nFirst < 0)
        nFirst = 0;

    if (nFirst >= m_nLength)
        nFirst = m_nLength - 1;

    int nEndPos = nFirst + nCount - 1;
    if (nEndPos < nFirst)
        nEndPos = nFirst;

    if (nEndPos >= m_nLength)
        nEndPos = m_nLength - 1;
    char *pTemp = GetSubstring(m_str, nFirst, nEndPos);
    CMyString strTemp(pTemp);
    delete []pTemp;
    return strTemp;
}

CMyString CMyString::MidSubString(int nFirst)
{
    if (nFirst < 0)
        nFirst = 0;

    if (nFirst >= m_nLength)
        nFirst = m_nLength - 1;

    char *pTemp = GetSubstring(m_str, nFirst, m_nLength - 1);
    CMyString strTemp(pTemp);
    delete []pTemp;
    return strTemp;
}

char* CMyString::GetSubstring(const char *strSource, const unsigned int uStartPos, const unsigned int uEndPos)
{
    unsigned int uLen = MyStrlen(strSource);  
    if (uLen == 0)  
    {  
        return "";  
    }  
    char *strTemp = new char[uLen + 1];
    memset(strTemp, 0, uLen + 1);  
    strcpy(strTemp, strSource);  

    if(uStartPos > uLen)  
    {  
        delete []strTemp;
        return "";  
    }  

    uLen = uEndPos - uStartPos + 1;
    char *strSub = new char[uLen + 1];
    memset(strSub, 0, uLen+1);  

    unsigned int i;
    for(i = 0; i < uLen; i++)  
    {  
        strSub[i] = strTemp[uStartPos + i];  
    }  
    strSub[i] = '\0';  

    delete []strTemp; 

    return strSub;
}

int CMyString::MyStrstr(const char *s1, const char *s2, int nStartPos)
{
    size_t l1, l2; 
    l2 = MyStrlen(s2);
    if (!l2)
        return nStartPos;

    int nPos = 0;
    l1 = MyStrlen(s1);
    while (l1 >= l2) 
    {
        l1--;
        if (!memcmp(s1, s2, l2))
            return nStartPos + nPos;
        s1++;
        nPos++;
    }

    return -1;
}

int CMyString::FindString(const CMyString& other)
{
    return MyStrstr(m_str, other.m_str);
}

int CMyString::FindString(const char* str)
{
    return MyStrstr(m_str, str);
}

int CMyString::FindString(const CMyString& other, int nStart)
{
    return MyStrstr(m_str + nStart, other.m_str, nStart);
}

int CMyString::FindString(const char* str, int nStart)
{
    return MyStrstr(m_str + nStart, str, nStart);
}

int CMyString::FindChar(char ch)
{
    for (int i = 0; i < m_nLength; i++)
    {
        if (m_str[i] == ch)
            return i;
    }
    return -1;
}

int CMyString::FindChar(char ch, int nStart)
{
    for (int i = nStart; i < m_nLength; i++)
    {
        if (m_str[i] == ch)
            return i;
    }
    return -1;
}

void CMyString::MakeReverse()
{
    for (int i = 0; i < m_nLength / 2; i++)
    {
        char ch = m_str[i];
        m_str[i] = m_str[m_nLength - 1 - i];
        m_str[m_nLength - 1 - i] = ch;
    }
}

int CMyString::Remove(char ch)
{
    int nNewLen = 0;//删除后的长度
    for (int i = 0; i < m_nLength; i++)
    {
        if (m_str[i] != ch)
            m_str[nNewLen++] = m_str[i];
    }
    m_str[nNewLen] = '\0';
    int nDeleteCount = m_nLength - nNewLen;
    m_nLength = nNewLen;
    return nDeleteCount;
}

int CMyString::Replace(char chOld, char chNew)
{
    int nCount = 0;
    for (int i = 0; i < m_nLength; i++)
    {
        if (m_str[i] == chOld)
        {
            m_str[i] = chNew;
            nCount++;
        }
    }
    return nCount;
}

int CMyString::Replace(char* pOld, char* pNew)
{
    int nOldLen = MyStrlen(pOld);
    int nNewLen = MyStrlen(pNew);
    int nPos = 0;
    while (1)
    {
        nPos = MyStrstr(m_str + nPos,  pOld, nPos);
        if (-1 == nPos)
            break;

        char *pTemp = new char[m_nLength + nNewLen + 1];
        memset(pTemp, 0, m_nLength + nNewLen + 1);

        char *pSub1 = NULL;
        if (nPos >= 1)
        {
            pSub1 = GetSubstring(m_str, 0, nPos - 1);
            MyStrcpy(pTemp, pSub1);
            delete []pSub1;
        }

        MyStrcat(pTemp, pNew);

        pSub1 = GetSubstring(m_str, nPos + nOldLen, m_nLength - 1);
        MyStrcat(pTemp, pSub1);
        delete []pSub1;

        delete []m_str;

        nPos += nNewLen;

        m_str = pTemp;
        m_nLength = MyStrlen(pTemp);

    }
    return 0;
}

int CMyString::Insert(int nIndex, char ch)
{
    char *pTemp = new char[m_nLength + 2];
    memset(pTemp, 0, m_nLength + 2);

    char *pSub1 = NULL;
    if (nIndex >= 1)
    {
        pSub1 = GetSubstring(m_str, 0, nIndex - 1);
        MyStrcpy(pTemp, pSub1);
        delete []pSub1;
    }

    pTemp[nIndex] = ch;

    pSub1 = GetSubstring(m_str, nIndex, m_nLength - 1);
    MyStrcat(pTemp, pSub1);
    delete []pSub1;

    delete []m_str;

    m_str = pTemp;
    m_nLength = MyStrlen(pTemp);

    return m_nLength;
}

int CMyString::Insert(int nIndex, char* pStr)
{
    int nInsertLen = MyStrlen(pStr);
    char *pTemp = new char[m_nLength + nInsertLen + 1];
    memset(pTemp, 0, m_nLength + nInsertLen + 1);

    char *pSub1 = NULL;
    if (nIndex >= 1)
    {
        pSub1 = GetSubstring(m_str, 0, nIndex - 1);
        MyStrcpy(pTemp, pSub1);
        delete []pSub1;
    }

    MyStrcat(pTemp, pStr);

    pSub1 = GetSubstring(m_str, nIndex, m_nLength - 1);
    MyStrcat(pTemp, pSub1);
    delete []pSub1;

    delete []m_str;

    m_str = pTemp;
    m_nLength = MyStrlen(pTemp);

    return m_nLength;
}

void CMyString::Sort()
{
    for (int i = 0; i < m_nLength; i++)
    {
        for (int j = i + 1; j < m_nLength; j++)
        {
            if (m_str[i] > m_str[j])
            {
                char ch = m_str[i];
                m_str[i] = m_str[j];
                m_str[j] = ch;
            }
        }
    }
}

int CMyString::MyIsSpace(char ch)
{
    if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\f' || ch == '\v' || ch == '\r')
        return 1;
    return 0;
}

int CMyString::MyIsDigit(char ch)
{
    if (ch >= '0' && ch <= '9')
        return 1;
    return 0;
}

int CMyString::MyAtoi(const char* pStr)
{
    char sign;
    int nValue = 0;
    while (MyIsSpace(*pStr))//去掉空字符
        pStr++;

    sign = *pStr;
    if (sign == '-' || sign == '+')
        pStr++;

    while (MyIsDigit(*pStr))
    {
        nValue = 10 * nValue + (*pStr - '0');
        pStr++;
    }

    return sign == '-' ? -nValue : nValue;
}

int CMyString::ToInt()
{
    return MyAtoi(m_str);
}

std::ostream& operator<<(std::ostream& os, CMyString& other)
{
    os << other.m_str;
    return os;
}

std::istream& operator>>(std::istream& in, CMyString& other)
{
    char temp[1024];
    in >> temp;
    other = temp;
    return in;
}

04 | 设计模式

1. Singleton

• 懒汉模式

class singleton
{
protected:
    singleton()
    {
        pthread_mutex_init(&mutex);
    }
private:
    static singleton* p;
public:
    static pthread_mutex_t mutex;
    static singleton* initance();
};

pthread_mutex_t singleton::mutex;
singleton* singleton::p = NULL;
singleton* singleton::initance()
{
    if (p == NULL)
    {
        pthread_mutex_lock(&mutex);
        if (p == NULL)
            p = new singleton();
        pthread_mutex_unlock(&mutex);
    }
    return p;
}

• 饿汉模式

class singleton
{
protected:
    singleton()
    {}
private:
    static singleton* p;
public:
    static singleton* initance();
};
singleton* singleton::p = new singleton;
singleton* singleton::initance()
{
    return p;
}