Unpredicted infinite for loop in c++

Question

I am writing a program to return first occurrence of the character and the frequency of that character in the string. For loop in the function is executing infinite times and if condition and block is not executing even once.

What is the problem?

string::size_type find_ch(string &str,char ch,int& i_r)
{
    string::size_type first=0;
    for(auto i=str.size()-1;i>=0;i--)
    {
        cout<<"\nInside a for loop."<<endl;
        if(str[i]==ch)
        {
            cout<<"Inside if."<<endl;
            first=i+1;
            i_r++;
        }
    }
    return first;
}

Answer 1

This loop:

for(auto i = str.size() - 1; i>=0; i--)

will only exit when i is less than 0. But this is not a valid value for an unsigned int. The value will wrap to the maximum unsigned int, and you get an infinite loop.

Note that .size() on a std::string returns a size_t, which is basically an unsigned int type.

One way to fix this would be to cast the return type of .size() to an int, like this:

for(auto i = static_cast<int>(str.size()) - 1; i>=0; i--)

Note that it's important to do the cast before subtracting 1, otherwise you'll get the wrong answer when str is empty.

In c++20, you can avoid this issue entirely by calling the std::ssize() free function, which returns a signed version of the size.

Answer 2

The function definition in general is wrong.

For example if the given character is nit found then why does the function return 0 that is a valid position?

Returning the value first=i+1; will only confuse users of the function. The function shall return std::string::npos if the given character is not found.

Also it is entirely unclear why the loop starts from the end of the string while you need to return the first position of the character.

As for the infinite loop then in the loop there is used variable i that has the unsigned integer type std::string::size_type a value of which never can be negative.

for(auto i=str.size()-1;i>=0;i--)
    ^^^^^^^^^^^^^^^^^^^

That is the condition i >= 0 is always true by the definition.

The function should be defined the following way

std::pair<std::string::size_type, std::string::size_type> find_ch( const std::string &str, char ch )
{
    auto n = str.find( ch );

    std::pair<std::string::size_type, std::string::size_type> p( n, 0 );

    if ( n != std::string::npos )
    {
        ++p.second;
        while ( ( n = str.find( ch, n + 1 ) ) != std::string::npos ) ++p.second;
    } 

    return p;
}

Here is a demonstrative program.

#include <iostream>
#include <string>
#include <utility>

std::pair<std::string::size_type, std::string::size_type> find_ch( const std::string &str, char ch )
{
    auto n = str.find( ch );

    std::pair<std::string::size_type, std::string::size_type> p( n, 0 );

    if ( n != std::string::npos )
    {
        ++p.second;
        while ( ( n = str.find( ch, n + 1 ) ) != std::string::npos ) ++p.second;
    } 

    return p;
}

int main() 
{
    std::string s( "C++ is not the same as C" );

    auto p = find_ch( s, 'C' );

    if ( p.first != std::string::npos )
    {
        std::cout << p.first << ": " << p.second << '\n';
    }

    return 0;
}

The program output is

0: 2

If you are not allowed to use methods of the class std::string then just substitute calls of the method find in the function above to while loops as it is shown below.

#include <iostream>
#include <string>
#include <utility>

std::pair<std::string::size_type, std::string::size_type> find_ch( const std::string &str, char ch )
{
    std::pair<std::string::size_type, std::string::size_type> p( std::string::npos, 0 );

    std::string::size_type n = 0;

    while ( n < str.size() && str[n] != ch ) ++n;

    if ( n != str.size() )
    {
        p.first = n;
        ++p.second;
        while ( ++n != str.size() )
        {
            if( str[n] == ch ) ++p.second;
        }           
    } 

    return p;
}

int main() 
{
    std::string s( "C++ is not the same as C" );

    auto p = find_ch( s, 'C' );

    if ( p.first != std::string::npos )
    {
        std::cout << p.first << ": " << p.second << '\n';
    }

    return 0;
}

Answer 3

Here is an answer similar to @Vlad From Moscow, but uses string functions, and the algorithm std::count.

#include <algorithm>
#include <string>
#include <utility>
#include <iostream>

std::pair<int,int> find_ch(const std::string &str, char ch)
{
    std::pair<int, int> ret;
    auto pos = str.find_first_of(ch);
    if ( pos == std::string::npos )
       return {-1,0};  // not found
    return { pos, std::count(str.begin() + pos, str.end(), ch) };
}

int main()
{
   auto pr = find_ch("abccabc", 'b');
   std::cout << "character b is at position " <<  pr.first << ".  Character count is  " << pr.second << "\n";
   pr = find_ch("abccabc", 'c');
   std::cout << "character c is at position " <<  pr.first << ".  Character count is  " << pr.second;
}

Output:

character b is at position 1.  Character count is  2
character c is at position 2.  Character count is  3

Each line of the function basically describes what is being done:

find_first_of the character in the string. If found then return that position and the std::count of that character starting at the first occurrence.

Note the brevity and self-documented way the function is written. A C++ programmer could look at that code and immediately know what it does, due to the names of the functions that are being called.

Writing loops going backwards (as you originally did) with variables incremented here and there, the programmer has to sit down and go through the code to figure out what it is doing, and what the purpose of the function is.