Scoping issue with a helper method to manipulate a string - c++

Question

I want to use a helper method to perform an operation on a string. I would like the method to have two parameters: input and output. I think there is a scoping problem with how I want to solve the problem because when I try to display the output, it is blank. I've minimized my code so you can see the approach I am taking.
#include <iostream>
#include <string>
using namespace std;
void example_method(string in, string out);
int main(){
string input;
string output;
cin >> input;
example_method(input, output);
cout << "The result is: " << output << endl;
return 0;
}
void example_method(string in, string out){
out = in;
}
This minimization compiles and runs, but no matter what string I enter, the result is always blank.
What would be a better way to approach this problem?

Answer 1

You're passing the output variable to the function, which means a copy of it is being pushed onto the stack, and then the stack variable is being altered and never returned back to the original variable. What you want to do is pass a reference to the variable, Like so:
#include <iostream>
#include <string>
using namespace std;
void example_method(string in, string &out);
int main() {
string input = "";
string output = "";
cin >> input;
example_method(input, output);
cout << "The result is: " << output << endl;
return 0;
}
void example_method(string in, string &out) {
out = in;
}

Answer 2

Solution One: The string output will always be blank, with your code in its present form. This is because output is only being copied to another string instance when it is passed as an argument to example_method. out is the other string instance which takes the value of output. In other words what this means is that string out=output and nothing else. The code line out = in; only copies the value of in to out.
So, actually the value of output is not being acted upon at all.
In order to effect the value of output you have to pass its value by reference or in other words, you have to pass the address of output to example_method and that address is to be taken by a pointer. This way what ever changes are made via the pointer also effect the value of the output string outside the scope of the example_method.
The following code segment illustrates my point:
#include <iostream>
#include <string>
using namespace std;
void example_method(string another_string, string *pointer_to_output);
int main()
{
string input="I am a test string";
string output="";
//cout<<"Enter input string"<<endl;
//cin>>input;
example_method(input,&output);
cout<<"The result is: "<<output<<endl;
return 0;
}
void example_method(string another_string, string *pointer_to_output)
{
*pointer_to_output=another_string;
}
Solution two:
Why not simply change the return type of the example_method from void to std::string? By this approach void example_method(string in, string out); changes to string example_method(string in, string out); in the declaration above the main.
And the returned output string is put out on the screen using cout<<example_method(input, output);
This way you can simply return your output to the screen using cout.
This way your code works, it achieves what you are trying to do and there is no real need of using pointers.
THE MODIFIED CODE:
#include <string>
using namespace std;
string example_method(string in, string out);
int main(){
string input;
string output;
cin >> input;
cout<<example_method(input, output);
// cout << "The result is: " << output << endl;
return 0;
}
string example_method(string in, string out){
out = in;
return out;
}
Hope this helps!

Answer 3

When you pass a argument to a function, the value is copied into the parameter.
In your case, the function will operate on the copied value, and leave the original value untouched (in this case: empty).
This can be changed by declaring the parameter as a 'reference parameter'. This is done by adding a & to the type, like this: string& out. Then no local copy will be made, so the original value will be updated.
Full example:
#include <iostream>
#include <string>
void example_method(std::string in, std::string& out); // note the additional &
int main(){
std::string input;
std::string output;
std::cin >> input;
example_method(input, output);
std::cout << "The result is: " << output << std::endl;
return 0;
}
void example_method(std::string in, std::string& out){ // Note the additional &
out = in;
}
A different approach is to specify a return value for the function.
Your function is returning nothing (void), so you could return the resulting string instead. In that case, the output parameter is no longer required, but you'll have to assign the returned value to the output variable at the calling site.
A complete example:
#include <iostream>
#include <string>
std::string example_method(std::string in); // note that 'output' is gone
int main(){
std::string input;
std::cin >> input;
std::string output = example_method(input);
std::cout << "The result is: " << output << std::endl;
return 0;
}
std::string example_method(std::string in){
return in; // use 'return' to return a value.
}