Can someone explain how this function works? - c++

Question

I was wondering if anyone could help me understand this code by just talking me through the trace of the code because I get confused with what the int pos variable actually does or is used for when it gets to the if statement. my confusion is mostly concerned with the if statement. for this code I'll give the function the string "hello" and after it runs data2 should hold the character string "helo" with one "l" because it removed the duplicates.
I was just hoping someone could walk me through an in depth trace of the code so I can understand it more because my c++ book doesn't explain the ".find()" function too well. I hope this is easy to explain, because I really want to learn this!!
Thankyou!
string data("hello");
string duplicates(string &data)
{
string data2;
int pos;
for(int i=0;i<data.length();i++)
{
if((pos=data2.find(data[i]))<0){
data2 += data[i];
}
}
return data2;
}

Answer 1

It either returns the empty string, or invokes undefined behavior by castimg an unsigned value that is out of ints range. While signed to unsigned conversions are safe and well defined, round tripping is only safe for the values both can represent. Some compilers will exploit this to eliminate branches only reachable with UB.
On a particular implementation of C++ it may do something in particular.
The programmer writing this bit of code screwed up in a way that probably worked every time it was tested. If they eliminated pos as a variable, removed the assignment (keepimg the right hand side) in the if clause, and replaced -1 with std::string::npos the code both becomes easier to understand and probably what the coder intended.
I am assuing that the strings in question are std::string:
duplicates takes a std::string called data by reference (so it can modify it) and returns another std::string:
std::string duplicates(std::string &data)
{
It has two local variables, data2 and pos. data2 is a std::string and pos is an int (the "default" signed integer for the compiler, usually 2s complement, at least 16 bits, usually 32 bits):
std::string data2;
int pos;
We loop the local variable i from 0 to 1 less than data.length(). So i varies over the valid indexes into data. Note that if data's length is longer than the max value an int can store, this invokes undefined behavior (but that is unlikely, unless int is very small, or the string is very very long (billions of characters):
for(int i=0;i<data.length();i++)
{
Here we do two things at once. This is generally considered bad coding practice. We assign the return value of data2.find(data[i]) to pos (converting the std::size_t implicitly to an int), then check if it is less than 0 and branch based on that.
There are a few problems here. Converting a std::size_t to int invokes undefined by the standard behavior. Many compilers will do a 2s complement truncating cast, but this is not guaranteed, and other compilers will use the fact that the only way a std::size_t could convert to an int less than zero is undefined behavior, and optimize out the branch completely (gcc, for example, with certain flags):
if((pos=data2.find(data[i]))<0) {
the other problem being needlessly doing 2 things at once. Putting this on two lines causes no harm.
The programmer intended this line of code to run if and only if data[i] was not found in data2. If so, it appends that character into data2. As noted, the programmer failed, except if they got "lucky" with undefined behavior: (their tests all got "lucky" I'm certain):
data2 += data[i];
}
}
We then return what the programmer intended to be a string containing each unique character in data:
return data2;
}
I will rewrite the code to be non-horrible. First, C++03 style:
std::string duplicates(std::string const&data) {
std::string data2;
for(int i=0;i<data.length();++i) {
std::size_t pos = data2.find(data[i]);
if(pos == std::string::npos) {
data2 += data[i];
}
}
return data2;
}
next, C++11 style:
std::string duplicates(std::string const& data) {
std::string data2;
for( char c : data ) {
auto pos = data2.find(c);
if(pos == std::string::npos) {
data2 += c;
}
}
return data2;
}

Answer 2

The code below is the key code:
if((pos=data2.find(data[i]))<0){
data2 += data[i];
data[i] is going to get each character of the source string. Pretend we store this in 'C'.
data2.find(C) is now going to search for this character inside the NEW string. Call this result 'R'
if ((pos=R)<0) { } is checking if the character was NOT found. -1 will be returned if not found. If it is not found, then the character will be added to the destination string using data2 += data[i];
Note that this is complicated by they fact they are storing the pos, but its not used, so it could read:
string duplicates(string &data)
{
string data2;
for(int i=0;i<data.length();i++)
{
if(data2.find(data[i])<0)
{
data2 += data[i];
}
}
return data2;
}

Answer 3

What's happening here is pretty straightforward. A string is passed in to the function, and we loop over this string, examining each character in the string individually. The only complication is at the statement if((pos=data2.find(data[i]))<0). Let's break it down:
data2.find(data[i]) - this calls the find function from the string class. Given some sequence, it finds the index of the first occurrence of that sequence within the string. If the sequence is not found it returns an error value. For our intents, we can assume this value is -1. It's actually a bit more complicated than that, but for now this is enough. So to recap: 0 and up means sequence was found, -1 means not found.
pos=data2.find(data[i]) - we assign that index to a variable.
pos=data2.find(data[i]))<0 - we check the index that was returned. Since if the sequence is not found, -1 is returned, this check will evaluate to true if -1 is returned.
...And that's basically it. It's easier to read the code if we restructure the loop like so:
for(int i=0;i<data.length();i++)
{
pos=data2.find(data[i]);
if(pos < 0) {
data2 += data[i];
}
}

Answer 4

basically, this function make a string with unique character of the input string.
First, you need to know that .find return the position of the character given in parameter, or return string::npos (-1) if the character wasn't found.
So if you put "hello", it goes like this :
data2 = ""
data2.find('h') == -1
data2 = "h"
data2.find('e') == -1
data2 = "he"
data2.find('l') == -1
data2 = "hel"
data2.find('l') == 2
data2 = "hel"
data2.find('o') == -1
data2 = "helo"
so, what's the utility of pos ? .find return an unsigned int so checking if an unsigned int goes bellow 0 will always return false, so we store it in an int and we can do the comparison.
but wait, there is more. you may ask how a unsigned int can be equal -1 ? you can read this will waiting for more complete answer of a more competent guys