Why isn't this processing function returning anything related to the string?

Question

I have a function,

string readWord(string line, int start) {
    int i = 0; string out = "";
    while(line[start + i] = 'a' || 'b' || 'c' || 'd' || 'e' || 'f' || 'g' || 'h' || 'i' || 'j' || 'k' || 'l' || 'm' || 'n' || 'o' || 'p' || 'q' || 'r' || 's' || 't' || 'u' || 'v' || 'w' || 'x' || 'y' || 'z' || 'A' || 'B' || 'C' || 'D' || 'E' || 'F' || 'G' || 'H' || 'I' || 'J' || 'K' || 'L' || 'M' || 'N' || 'O' || 'P' || 'Q' || 'R' || 'S' || 'T' || 'U' || 'V' || 'W' || 'X' || 'Y' || 'Z') {
        i++;
        out = out + line[start + i];
    }
    return out;
}

The function didn't give me any compiler errors or warnings, so I decided to see if it worked. I printed readWord("Word1 Word(2) Word3", 0), and it gave me "free(): invalid pointer." Do you know how I can get it to do what I want?

Answer 1

As noted in comments, you have multiple issues which likely come down to confusion about C++'s basic syntax.

line[start + i] = 'a' is an assignment and not a comparison. Incidentally, it's also "true."

You were probably looking for line[start + i] == 'a' to compare the two for equality.

Second, you cannot check multiple values for equality against a single value with expressions of the form a == b || c || d.

There are varying approaches to this, but the simplest would probably be a == b || a == c || a == d.

More succinct in your case would be to include <cctype> and then:

string readWord(string line, int start) {
    int i = 0; string out = "";
    while(std::isalpha(line[start + i])) {
        i++;
        out = out + line[start + i];
    }
    return out;
}

Or, leveraging C++ techniques a bit more, we can find the first character that doesn't match with a letter of the alphabet, and use that iterator along with a start iterator to initialize a new string.

#include <cctype>
#include <string>
#include <iostream>

int main() {
    std::string s = "hello world!";
    
    auto end = std::find_if(
      s.begin(), s.end(), 
      [](auto &c){ return !std::isalpha(c); }
    );

    // C++20:
    // auto end = std::find_if_not(s.begin(), s.end(), std::isalpha);

    std::string s2(s.begin(), end);

    std::cout << s2 << std::endl;
}

The above will print "hello".

Answer 2

The = operator is the assignment operator as opposed to the comparison operator == which you should be using in this case.

If you want to compare a variable against multiple values, you should use the following syntax:

while(x == 1 || x == 2 || x == 3) // etc.

Another issue in your code is that you're incrementing i too early, it should be after the assignment to out. Here is a demonstration on how to fix the issues in your code:

#include <iostream>       
#include <string>

std::string readWord(std::string line, int start)
{
    int i = 0;
    std::string out = "";

    while (line[start + i] == 'a' || line[start + i] == 'b')
    {
        out += line[start + i];
        i++;
    }
    return out;
}

int main()
{
    std::string A = readWord("a012b3", 0);
    std::cout << A << std::endl;
    return 0;
}

Answer 3

The comments below explain some the issues that I think you were having trouble with. Hope this helps!

This is a complete program. It runs.

#include <iostream>
#include <string>

// Avoid `using namespace std;`.
// Instead, just write out `std::` every time you use `string` or `cout`.

bool is_alpha(char const c) 
{
    // Check out function `std::isalpha` found in header `<cctype>`. 
    // It does something similar to what this function is doing.
    return ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z');
}

// `std::string const&` means `reference to const std::string`. 
// It reads backwards from right-to-left. This method for passing strings 
// is usually more efficient when you do not want to modify them.
//
// `int&` means `reference to int` (also reading backwards).
// By using this as the type for parameter `pos`, you make it so that 
// changes made to `pos` in this function also happen in the calling 
// routine. When this routine it finished, `pos` will have been changed 
// to the position where we stopped in this function.
// 
std::string readWord(std::string const& line, int& pos) 
{
    std::string out;
    while (pos < line.size() && is_alpha(line[pos]))
    {
        out.push_back(line[pos]);  // add one character to the end of string `out`
        ++pos;  // prefer `prefix increment` over `postfix increment` for most uses
    }
    return out;
}

void skip_over_non_letters(std::string const& line, int& pos)
{
    while (pos < line.size() && !is_alpha(line[pos]))
    {
        ++pos;
    }
}

int main()
{
    std::string line{ "Rock 'n roll rules the world." };
    std::string word;
    int pos = 0;
    while (pos < line.size())
    {
        skip_over_non_letters(line, pos);
        if (pos < line.size())
        {
            word = readWord(line, pos);
            std::cout << word << '\n';
        }
    }
    return 0;
}

Running it produces the following output:

Rock
n
roll
rules
the
world