2

创建一个自定义 String 类，我在重载 '<<' 运算符以进行输出时遇到问题。我尝试了几种不同的编写方式（在下面的代码中注释掉，以供参考，因为它们不起作用），并得到各种错误。对于初学者，我从下面的代码中得到的错误是：

错误 1：错误 C2804：二进制 'operator <<' 参数过多 第 53 行

错误 2: 错误 C2333: 'String::operator <<' : 函数声明错误；跳过函数体第 53 行

错误 3：错误 C2679：二进制“<<”：未找到采用“字符串”类型右侧操作数的运算符（或没有可接受的转换）第 180 行（有一堆）

由于该文件超过 300 行，而且我怀疑你们是否需要通读它，我会--snip-- 其中一些，但如果您想要 300 行，我一定会编辑它。

另外，我知道标头中的“使用命名空间标准”是不好的做法。抱歉，这是我正在使用的旧文件，我保证不会将它包含在以后的头文件中。

也就是说，这是代码（非常感谢您的帮助）：

正如我之前所说，非常感谢下面阅读和回复的人。我花了将近两个小时试图找到一个可行的解决方案，而我搜索的帖子要么太复杂，我无法理解，要么不适用于我的案例。通过查看 cplusplus 网站，我看到 << 运算符函数只接受一个参数，但是在使其工作时遇到了问题。如果你们发布您认为可行的内容，我会尝试并回复。

谢谢大家！如果我遗漏任何重要信息，请告诉我。

#pragma once

#include <iostream>
#include <sstream>
using namespace std;

#define NOT_FOUND -1

//ostream& operator << (ostream& out, const String& myString);

// C++ String class that encapsulates an ASCII C-string
class String
{
public:
    // Default constructor
    String()
    {
        Text = NULL;
    }
    
    // MUST HAVE: Copy-constructor that performs deep copy
    String(const String& source)
    {
        Text = NULL;
        // Call the assignment operator to perform deep copy
        *this = source;
    }
    
    // Init-constructor to initialize this String with a C-string
    String(const char* text)
    {
        Text = NULL;
        // Call the assignment operator to perform deep copy
        *this = text;
    }
    
    // Init constructor, allocates this String to hold the size characters
    String(int size)
    {
        Text = new char[size];
    }
    
    // Destructor
    ~String()
    {
        delete[] Text;
    }
    
    // This is what I would love to have work.
    ostream& operator << (ostream& out, const String& myString)
    {
        return out << myString.GetText();
    }
    // Returns a new string that corresponds to a substring of this String
// beginning at startPosition and length chars long;
// if length = 0 (not specified) then the substring spans from
// startPosition until the end of this String
// throws an exception when startPosition is out of bounds
String Substring(int startPosition, int length) const
{
    char * str = this->GetText();
    String returnString;
    int strLength = length;
    int x = 0;

    if(length == 0)
        strLength = GetLength(str)-startPosition;

    char* substring = new char[strLength];

    // Makes sure the starting position is within the bounds of the String 'this'
    try
    {
        CheckBounds(startPosition, str);
    }
    catch(char * error)
    {
        cout << error << endl << endl;
    }

    // In case the substring length is too long, it cuts short once it reaches the end of the original string. Yu-San, this is #2 on the three options you said I could implement, FYI.
    while(x < strLength && str[x+startPosition]!='\0')
    {
        substring[x] = str[x + startPosition];
        x++;
    }
    substring[x]='\0';
    //for(int x = 0; x<strLength; x++)
    //{
    //returnString = str + startPosition;
    returnString = substring;
    //}

    return returnString;    
}
    // Assignment operator to perform deep copy
    String& operator = (const char* text)
    {
        // Ddispose of old Text
        delete[] Text;
        
        // +1 accounts for NULL-terminator
        int trueLength = GetLength(text) + 1;
        
        // Dynamically allocate characters on heap
        Text = new char[trueLength];
        
        // Copy all characters from source to Text; +1 accounts for NULL-terminator
        for ( int i = 0; i < trueLength; i++ )
            Text[i] = text[i];
        
        return *this;
    }
    
    // Returns the count of characters in a C-string text; NULL-terminator is not counted
    // static means that the member function neither reads nor
    // writes any of the class' data members
    // String::GetLength("blah");
    static int GetLength(const char* text)
    {
        int x = 0;
        while(text[x] != '\0')
            x++;
        
        return x;
    }
    
    // Returns a reference to a single character from this String
    char& operator [] (int index) const
    {
        int length = GetLength();
        
        // Check for valid index
        if ( (index < 0) || (index > length) )
        {
            stringstream error;
            error << "operator[] - index " << index << " is out of bounds (0.." << (length - 1) << ")";
            throw String(error.str().c_str());
        }
        
        return Text[index];
    }
// Returns the count of characters in the String; NULL-terminator is not counted
int GetLength() const
{
    return GetLength(Text);
}



char* GetText() const
{
    return Text;
}

// Finds first index of a symbol not found in "text" in string *this
int FindFirstNotOf(char * text)
{
    String objectString(*this);
    int x = 0; // loop counter
    int firstIndex = 0; // index to return

    while(text[x]!='\0')
    {
        // runs each character in 'text' against each character in the object.
        for(int y = 0; y<objectString.GetLength(); y++)
        {
            if(objectString[x] == text[x])
                objectString[x] = '\0';
        }

        x++;
    }

    while(objectString[firstIndex]=='\0' && (firstIndex<objectString.GetLength()))
    {
        firstIndex++; //keeps running until it Finds a character that wasn't changed to \0
    }

    if(firstIndex == objectString.GetLength())
        firstIndex = -1; // means it wasn't found.

    return firstIndex;
}

int FindFirstOf(char iWantThis)
{
    String objectString(*this);
    int firstIndex = 0; // index to return

    while(objectString[firstIndex]!=iWantThis && (firstIndex<objectString.GetLength()))
    {
        firstIndex++; //keeps running until it Finds a character that wasn't changed to \0
    }

    if(firstIndex == objectString.GetLength())
        firstIndex = -1; // means it wasn't found.

    return firstIndex;
}

int FindLastOf(char iWantThis)
{
    String objectString(*this);
    int index = 0;
    int lastIndex = -1;

    while(objectString[index]!='\0')
    {
        if(objectString[index] == iWantThis)
            lastIndex = index;
    }

    return lastIndex;
}

// finds a desired char in String object, with default start index of 0
int Find (char iWantThis, int startIndex = 0)
{
    int index = -1;
    int ctr = startIndex;

    String objectString(*this);

    while(objectString[ctr]!='\0' && index == -1) // runs until it reaches end, or the return index is changed
    {
        if(objectString[ctr] == iWantThis)
            index = ctr;
        else
            ctr++;
    }

    return index;
}

private:

// Throws an String-type exception when index is out of bounds
void CheckBounds(int index, const char* source) const
{
    int size = GetLength(source);

    if(index < 0 && index >=size)
        throw "Selected Starting Index is Out of Bounds.";  
}

// The encapsulated C-string
char* Text;
};


// Stream output operator to print String to output stream
/* ostream& operator << (ostream& out, const String& myString)
 * {
 *  return out << myString.GetText();
 * };
 */
4

1 回答 1

2

您需要一个插入运算符才能成为自由函数：

在您的班级内部：

class String
{
   friend std::stream& operator <<(std::ostream&, const String&);
   ...
};

在您的班级之外：

inline std::ostream& operator << (std::ostream& os, const String& myString)
{
    os << myString.GetText();
    return os;
}

这假设GetText()是一个可行的成员函数，在您当前的代码片段中找不到它。我假设你在某个地方有一个。如果是，public则无需在类体中声明友元关系，只需使用自由函数插入操作符即可。

最后，这假设运算符是在头文件中实现的（因此是内联的）。如果将实现移至 .cpp 文件，请务必在标头中将其声明为全局原型，并删除inline.cpp 实现中的前导。

旁注：打破立即放入using namespace std;头文件的习惯。这是一种不好的做法，并且可能会对源文件（包括您的标头）产生不必要的副作用，而这些副作用不会被命名空间暴露。

于 2013-03-12T03:25:40.500 回答