C++ 程序中的分段错误查找重复字符串中的字符

Question

Following code counts total occurrence of a character,'a' in string,s repeated upto n number of characters:

#include<iostream>
using namespace std;

long repeatedString(string s, long n) 
{
    long count=0,i;
    char *s1{ new char[n]{} };
    int j=0;
    for(i=0;i<n;i++)
    {
        s1[i]=s[j++];
        if(j==s.size())
            j=0;
    }

    for(i=0;i<n;i++)
    {
        if(s1[i]=='a')
            count++;
    }
    return count;

}

int main()
{
   string s = "abaca";
   long n = 12;
   cout<<repeatedString(s,n);
   return 0;
}

It runs fine with following input:

Eg. Here s is " abaca ", s1 will be " abacaabacaab " so n gets calculated to 7.

But if s is " a " and n is 1000000000000 , it gets aborted due to bad_alloc

Can anyone help me solve this issue?

Thanks in advance!

Answer 1

We start with s1.size() == 0 and for a string s1[i] is invalid for any value of i greater or equal to s1.size() . In this case it is always invalid.

Change s1[i]=s[j++]; to s1 +=s [j++];

Answer 2

The object s1 of the type std::string is empty

string s1="";

So you may not use the subscript operator to change it

    s1[i]=s[j++];

You could declare the object like

string s1( n, ' ' );

In this case it contains n elements that can be changed using the subscript operator.

Another approach is to use the operator +=. For example

string s1;
s1.reserve( n );

//...

s1 += s[j++];

Pay attention to that the value 1000000000000 of the parameter n can be too big and the system will be unable to allocate such a string.

In this case you have to check whether the system is able to allocate enough elements for the object.

For example

string s1;

if ( not ( n < s1.max_size() ) ) n = s1.max_size();
s1.reserve( n );

and then

s1 += s[j++];

Pay attention to that the return type of the function should be at least size_t but it will be even better to use std::string::size_type .

Here is a demonstrative program

#include <iostream>
#include <string>

std::string::size_type repeatedString( const std::string &s, std::string::size_type n ) 
{
    std::string s1;

    if ( not( n < s1.max_size() ) ) n = s1.max_size();

    s1.reserve( n );

    for ( std::string::size_type i = 0, j = 0; i < n; i++ )
    {
        s1 += s[j++];

        if ( j == s.size() ) j = 0;
    }

    std::string::size_type count = 0;

    for ( const auto &c : s1 )
    {
        if ( c == 'a' ) ++count;
    }

    return count;
}

int main() 
{
    std::string s( "abaca" );

    std::string::size_type n = 12;

    std::cout << repeatedString( s, n ) << '\n';

    return 0;
}

Its output is

7

Instead of the range-based for loop in the function

    for ( const auto &c : s1 )
    {
        if ( c == 'a' ) ++count;
    }

you could use the standard algorithm std::count declared in the header <algorithm> .

If the system is unable to allocate a string of a given size then it throws an exception of the type std::bad_alloc . You can catch the exception.

In this case the function can look the following way as it is shown in the demonstrative program.

#include <iostream>
#include <string>

std::string::size_type repeatedString( const std::string &s, 
                                       std::string::size_type n ) throw( std::bad_alloc ) 
{
    std::string s1;

    if ( not( n < s1.max_size() - 1 ) ) n = s1.max_size() - 1;

    s1.reserve( n );

    return n;

    for ( std::string::size_type i = 0, j = 0; i < n; i++ )
    {
        s1 += s[j++];

        if ( j == s.size() ) j = 0;
    }

    std::string::size_type count = 0;

    for ( const auto &c : s1 )
    {
        if ( c == 'a' ) ++count;
    }

    return count;
}

int main() 
{
    std::string s( "a" );

    std::string::size_type n = 1000000000000;

    try
    {
        std::cout << repeatedString( s, n ) << '\n';
    }
    catch ( const std::bad_alloc & )
    {
        std::cout << n << " is too big value.\n";
    }

    return 0;
}

The program output might look like

1000000000000 is too big value.