Using char as a return type

Hey guys,

I am writing a C++ console app that carries on a conversation with the user. I need to be able to easily write functions that might take the user's input (type char), then make some decision about what to say, then finally return a value of type char. I would like to do it something like this... (leaving out irrelevant code)

Code:

---


char someFunction()
{
    char output;   
    ...
    ... // Decide what to say
    ...
    return output;
}

int main()
{
    cout << someFunction() << endl;
    return 0;
}

---

I can get it to compile without any errors, but I don't get the right output, I get goofy control characters. You can put a function inside a cout statement as long as the function return a char, right?

Just in case that's wrong, I also tried to get around that by doing this...

Code:

---


int main()
{
   
    char word;
    strcpy(word, someFunction());
   
    cout << word << endl;

    return 0;
}

---

Didn't work either. I could just put the cout statement inside the function, but that defeats the whole purpose of using encapsulation. I need to be able to write many small functions that return char because I will probably change this to a GUI later and the cout statements become useless.

Why is it showing control characters? What am I doing wrong?

The error is probably in how you're deciding what to say. Chars are valid for couting, as are strings.

>> (leaving out irrelevant code)
The first code you posted is correct, the relevant code is what is missing.

>> char word;
>> strcpy(word, someFunction());

This shows a lack of understanding of what a char is and what a string is. The strcpy function copies an array of characters (referred to as a string), but in that code word and the return of someFunction have the char type which holds only a single character.

You probably want to use the C++ string class to hold your strings. That can be returned from a function and output with cout.

yeah, looks to me like you're confusing chars with strings... you can use your code with just a few modifications:

Code:

---

#include <iostream>

//this is the function prototype
void someFunction(char*word);

int main()
{
        //here we assume a phrase no bigger than 512 characters
        char*word=new char[512];
        //I designed the someFunction function so that we don't need strcpy
        someFunction(word);
        //output the response
        std::cout<<word<<std::endl;
        //deallocate that space
        delete[]word;
        //END.
        return 0;
}

//function definition
void someFunction(char*word)
{
        //prompt for input
        std::cout<<"Hello World\n> "<<std::flush;
        //get their input, up to 20 chars and stopping when they hit "ENTER"
        std::cin.getline(word,20,'\n');
        //assign the response to the parameter
        strcpy(word,"Thank you for helping me test my AI");
        //bye.
        return;
}

---

here's an implementation using stl strings (this may be easier to use):

Code:

---

#include <iostream>
#include <string>

//this is the function prototype - notice the new ampersand (&)
void someFunction(std::string&word);

int main()
{
        //stl strings take care of most of your size woes
        std::string word;
        //I designed the someFunction function so that we don't need strcpy
        someFunction(word);
        //output the response
        std::cout<<word<<std::endl;
        //notice we dont' need to deallcoate anything
        //END.
        return 0;
}

//function definition - The ampersand (&) means we're passing in the address
//of the variable.
void someFunction(std::string&word)
{
        //prompt for input
        std::cout<<"Hello World\n> "<<std::flush;
        //Notice the changes in this next line - it still stops at ENTER, but
        //there are no size limitations (theoretically)
        getline(std::cin,word,'\n');
        //an easier assignment is now possible thanks to the string class
        word="Thank you for helping me test my AI";
        //bye.
        return;
}

---

Another example using the string class that more closely mirrors the original code:

Code:

---

#include <iostream>
#include <string>

std::string someFunction()
{
        std::string output;

        //prompt for input
        std::cout<<"Hello World\n> ";
        //Notice the changes in this next line - it still stops at ENTER, but
        //there are no size limitations (theoretically)
        std::getline(std::cin,output,'\n');
        //an easier assignment is now possible thanks to the string class
        output="Thank you for helping me test my AI";
        //bye.

        return output;
}

int main()
{
        //You don't need strcpy with strings and you don't need a temporary variable
        std::cout << someFunction() << std::endl;
        return 0;
}

---

Thanks major_small, you gave me the exact info I needed. :D