指针问题2 [有效的C ++语法]

Question

此版本正常运行。我在整个代码中发表了//条评论，以便更好地说明我遇到的问题。该程序依赖于读取文本文件。包含标点符号的段落格式。

可以将此内容和上述内容复制到文本文件中并运行该程序。

// Word.cpp

#define _CRT_SECURE_NO_WARNINGS // disable warnings for strcpy
#define ARRY_SZ 100
#include <iostream>
#include <fstream>
#include "Word.h"

using namespace std;

Word::Word( const char* word )
{
    ptr_ = new char[ strlen( word ) + 1 ];
    strcpy( ptr_, word  );  
    len_ = strlen( ptr_ );
}

Word::Word( const Word* theObject ) 
{
    ptr_ = theObject->ptr_;
    len_ = theObject->len_;
}

Word::~Word()
{
    delete [] ptr_;
    ptr_ = NULL;
}

char Word::GetFirstLetterLower()
{
    // I want to use ptr_ and len_ here
    // but the information is gone!
    char c = 0;
    return c;
}

char* Word::GetWord()
{
    for (int x = 0; x < strlen( (char*)ptr_ ); x++)
        ptr_[x];  // Results in a crash.

    return ptr_;
}

// Word.h

const int FILE_PATH_SZ = 512;
class Word
{
private:
    char* ptr_;
    int len_;
public:
    Word( const Word* ); // an appropriate default constructor
    Word( const char* );
    ~Word( );
    char GetFirstLetterLower( );
    char* GetWord( );
    static char fileEntry[ FILE_PATH_SZ ];
};

// main.cpp

#ifdef  _DEBUG
#define _CRTDBG_MAP_ALLOC
#include <iostream>
#include <fstream>
#include <string>
#endif
#include "Word.h"
using namespace std;

const int WORD_SZ = 100;
Word** g_wordArray;
int g_arrSz;

static char filePath[ FILE_PATH_SZ ] = {};
void FreeWordArray();

int main( const int argc, const char **argv )
{
    int     wrdCount = 0;
    char    usrMenuOption     = 0,
            getFirstLetter          = 0,
            tmpArray[WORD_SZ] = {},
            *getWord = 0;
    string  str, 
            str2;
    ifstream  inFile, 
              inFile2;

    do 
    {
        cout << "Please make a selection: \n\
a) Read a text file\n\
b) Remove words starting with letter\n\
c) Print words to console\n\
d) Quit\n";
        cin  >> usrMenuOption;
        switch( usrMenuOption )
        {
            case'A':
            case'a':
                cout << "Enter a file name: ";
                cin.sync();
                cin  >> filePath;
                inFile.open( filePath );
                if ( !inFile ) return -1;
                inFile >> str; // prime the eof flag
                while ( !inFile.eof() )
                {        
                    inFile >> str;
                    wrdCount++;
                    g_wordArray = new Word *[wrdCount];
                }
                inFile.close();
                inFile2.open( filePath );

                while( !inFile2.eof() )
                {
                    inFile2 >> str2;
                    for ( unsigned x = 0; x < str2.length(); x++ )
                    g_wordArray[x] = new Word( str2.c_str() );
                }
                cout << wrdCount << " Words read from the file " << endl;
                inFile2.close();
                break;
            case'B':
            case'b':
                getFirstLetter = g_wordArray[wrdCount]->GetFirstLetterLower();
                //getWord = g_wordArray[wrdCount]->GetWord();
                cout << getWord << endl;
                break;
            case'C':
            case'c':
                break;
            case'D':
            case'd':
                cout << "Quit Requested. " << endl;
                break;
            default:
                cout << '"' << usrMenuOption << '"' << " Not Defined! " << endl;
        }
    } while (usrMenuOption != 'D' && usrMenuOption != 'd');

#ifdef _DEBUG
    _CrtDumpMemoryLeaks();
#endif
    cin.ignore();
    return 0;
}

void FreeWordArray()
{
    // free the memory that is allocated
    return;
}

Answer 1

编辑：我已将此编辑置于顶部，因为它直接回答了您为何Word被破坏的问题。您的副本构造函数错误：

Word::Word( const Word* theObject ) 
{
    ptr_ = theObject->ptr_;
    len_ = theObject->len_;
}

这不会复制theObject->ptr_指向的内容，只是指针。因此，您实际上有两个Word个对象指向同一个内部字符串。当Word对象被删除时，这会非常糟糕。一个正确的实现（使用你所做的技术，我建议反对他们）将是这样的：

Word::Word( const Word* theObject ) 
{
    ptr_ = new char[theObject->len_ + 1 ];
    strcpy( ptr_, theObject->ptr_  );  
    len_ = theObject->len_;
}

编辑： Earwicker也注意到以下内容：

  

......虽然那个“复制构造函数”   不是复制构造函数。所以   编译器生成的仍然会   存在，并成员相同   复制，因此同样的问题   仍然存在。

要解决这个问题，你需要制作一个应该有原型的正确的复制构造函数：

Word::Word(const Word &theObject);

这里的代码也是：

while ( !inFile.eof() )
{        
    inFile >> str;
    wrdCount++;
    g_wordArray = new Word *[wrdCount];
}

像筛子一样泄漏！在读取每个字后重新分配g_wordArray，并完全忘记删除上一个字。我将再一次使用您尝试使用的技术展示一个理智的实现。

while (inFile >> str)
{        
    inFile >> str;
    wrdCount++;
}
g_wordArray = new Word *[wrdCount];

注意它如何计算单词，然后在知道分配多少后，再分配一次空间。现在g_wordArray已准备好用于最多wrdCount个单词对象。

原始答案：

为什么不用Word替换std::string类？这将使代码更小，更容易使用。

如果它让您更轻松，请执行以下操作：

typedef std::string Word;

然后你可以这样做：

Word word("hello");
char first_char = word[0];

加上它还有额外的好处，即无需使用.c_str()成员来获取c风格的字符串。

修改

我还会将您的g_wordArray更改为std::vector<Word>。这样你可以简单地做到这一点：

g_wordArray.push_back(Word(str));

没有更多动态分配！这一切都是为你完成的。单词数组的大小将仅受您拥有的RAM数量的限制，因为std::vector在您使用push_back()时会根据需要增长。

另外，如果你这样做...想一下如何计算单词数你只需要这样做：

g_wordArray.size();

无需手动跟踪它们的数量！

修改

此外，此代码已损坏：

while( !inFile2.eof() )
{
    inFile2 >> str2;
    ...
}

因为在尝试阅读之后未设置eof，所以最好使用此模式：

while(inFile2 >> str2)
{
    ...
}

将在EOF上正确停止。

最重要的是，如果你这样做，你应该写的实际代码非常少。

修改

这是我想你想要的直接实现示例。从菜单项看，似乎用户首先选择选项'a'，然后'b'零次或多次过滤掉一些单词，然后最后c打印结果（每行一个单词）。此外，由于点击Ctrl+D向程序发送EOF并使“while(std::cin >> option)”测试失败，因此不需要选项“D”。从而结束了该计划。 （至少在我的操作系统中，它可能是Windows的Ctrl + Z`。

此外，它没有做任何努力（也没有你的）处理标点符号，但这里是：

#include <string>
#include <vector>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <functional>
#include <iterator>

struct starts_with : public std::binary_function<std::string, char, bool> {
    bool operator()(const std::string &s, char ch) const {
        return s[0] == ch;
    }
};

void print_prompt() {
    std::cout << "Please make a selection: \na) Read a text file\nb) Remove words starting with letter\nc) Print words to console" << std::endl;
}

int main( const int argc, const char **argv) {
    std::vector<std::string> file_words;
    char option;
    print_prompt();
    while(std::cin >> option) {
        switch(option) {
        case 'a':
        case 'A':
            std::cout << "Enter a file name: ";
            // scope so we can have locals declared
            {
                std::string filename;
                std::string word;
                std::cin >> filename;
                int word_count = 0;
                std::ifstream file(filename.c_str());
                while(file >> word) {
                    file_words.push_back(word);
                }
                std::cout << file_words.size() << " Words read from the file " << std::endl;
            }
            break;
        case 'b':
        case 'B':
            // scope so we can have locals declared
            {
                std::cout << "Enter letter to filter: ";
                char letter;
                std::cin >> letter;

                // remove all words starting with a certain char
                file_words.erase(std::remove_if(file_words.begin(), file_words.end(), std::bind2nd(starts_with(), letter)), file_words.end());
            }
            break;          

        case 'c':
        case 'C':
            // output each word to std::cout separated by newlines
            std::copy(file_words.begin(), file_words.end(), std::ostream_iterator<std::string>(std::cout, "\n"));
            break;
        }
        print_prompt();
    }
    return 0;
}

Answer 2

在没有整个main.cpp的情况下，我确实在构造函数/析构函数集中发现了一个问题：

Word::Word( const Word* theObject ) 
{
    ptr_ = theObject->ptr_;
    len_ = theObject->len_;
}

Word::~Word()
{
    delete [] ptr_;
    ptr_ = NULL;
}

请注意，在复制构造函数中，只需指定内部指针以匹配要复制的对象。但是在析构函数中，您可以删除内部指针中的数据。

这是可以获得ulgy的地方：

Word w1 = Word("hello");
Word w2 = Word(w1);
delete w2;

现在，你的第一个字包含什么？指针将存在，但它引用的数据在w2的析构函数中被删除。

他们称之为“复制构造函数”，因为这就是你应该做的事情：复制这件事。

Answer 3

g_wordArray[wrdCount]是否是有效的Word对象？我的C ++很生疏，但它看起来像是超出了数组的末尾。此外，您似乎反复践踏inFile2循环中g_wordArray的内容：对于您读入str2的每个字符串，您将重新初始化g_wordArray中的第一个str2.length（）条目。这可以解释成员变量的明显破坏。最后，我不确定这一点，但str2.c_str（）返回的指针在你读入str2的新值后仍然有效吗？因此，你的GetWord（）循环可能会从strlen中获取一个垃圾值，并且可能会永远不会降落。