C++ selfString类的实现

主要功能为实现一个类，能够从文件中读取英文字符串，包含一个功能函数，其效果为从两个字符串中找到最长的共同单词，下面贴代码

#include <iostream>
#include<fstream>
#include<iomanip>
using namespace std;
//-----------------------
//类定义
//-----------------------
class selfString
{
private:
    char *text;
    int length;    
public:
    selfString(const char* filename)
    {
        fstream file;
        file.open(filename, ios::in);
        file.seekg(0, file.end);
        length = file.tellg();
        text = new char[length+1];
        file.seekg(0,file.beg);
        while(!file.eof())
        {
            file.getline(text,256);
        }
        file.close();
        cout << "创建成功" << endl;
    }
    ~selfString()
    {    
        delete[] text;
        cout << "析构成功" << endl;
    }
    friend char* find(selfString& a, selfString& b,char* );
    void show()
    {
        cout << text << endl;
        cout << "长度为：" << length << endl;
    }
};
//-----------------------
//函数定义
//-----------------------
char* find(selfString& a, selfString& b,char* maxWord)
{
    int Judge[20][20];
    int maxNum = 0;
    for (int i = 0; i < a.length; i++)
    {
        for (int j = 0; j < b.length; j++)
        {
            if (a.text[i] == b.text[j] && a.text[i]!=' ' && b.text[j]!=' ')
            {
                Judge[i][j] = 1;
            }
            else if(a.text[i] != ' ' && b.text[j] != ' ')
            {
                Judge[i][j] = 0;
            }
            else if((a.text[i] !=' ' && b.text[j] == ' ') || (a.text[i] == ' ' && b.text[j] != ' '))
            {
                Judge[i][j] = -1;
            }
            else
            {
                Judge[i][j] = -2;
            }
            cout <<setw(5) << Judge[i][j];
        }
        cout << endl;
    }
    for (int i = 0; i < a.length; i++)
    {
        for (int j = 0; j < b.length; j++)
        {
            if ((i!=0 && j!=0 && Judge[i][j] == 1 && Judge[i-1][j-1] == -2 ) || (i == 0 && j == 0 && Judge[i][j] == 1) || ((i == 0 && j!= 0) && Judge[i][j-1] == -1 && Judge[i][j] == 1) || ((i != 0 && j == 0) && Judge[i-1][j] == -1 && Judge[i][j] == 1))
            {
                int k = 1;
                while (Judge[i + k][j + k] == 1)
                {
                    k++;
                }
                if (k > maxNum && ((i+k!=a.length && j+k!=b.length && Judge[i+k][j+k] == -2) || (i+k == a.length && j+k!=b.length && Judge[i+k-1][j+k] == -1) || (i + k != a.length && j + k == b.length && Judge[i + k][j + k-1] == -1) || (i+k == a.length && j+k == b.length)))
                {
                    maxNum = k;
                    int l;
                    for (l = 0; l < k; l++)
                    {
                        maxWord[l] = a.text[i+l];
                    }
                    maxWord[l] = '\0';
                }
            }
        }
    }
    return maxWord;
}
//-----------------------
//主函数
//-----------------------
int main()
{
    selfString a("1.txt");
    a.show();
    selfString b("2.txt");
    b.show();
    char c[10];
    find(a, b, c);
    cout << c << endl;
}

 

回顾一下写的过程，遇到的知识点问题如下

1、 文件的读取与写入操作。本身的库使用较为陌生，查查资料后还是能得到解决。

在类的构造函数中使用了new的方式在堆区中申请空间，使空间的利用率更高。其中的一个小问题使成功读取文件中字符串长度后，申请的空间需要+1，这是字符数组的特性决定的，字符数组需要在结束位添加‘\0’，所以初步完成时会出现内存泄漏的问题。因为实际使用的空间大于申请的空间。

2、 功能函数的撰写。用一个二维数组能够很简洁的完成该问题，二维数组中标1的表示字符相同，连着好几个1则代表连续相同的字符，同时也需要注意单词前后应该都为-1，即空格。同时形参需要调整为类对像的引用，若非引用，则形参向实参传递的过程中需要调用复制构造函数。若无复制构造函数，则在临时对象释放调用析构函数时，会出现内存泄漏。