C ++识别字符串中的特殊字符

Question

I am writing a program for school that is supposed to check the strength of passwords and separate them into 3 parameters. I am having an issue identifying special characters in a strong to classify a strong character. any help is greatly appreciated.

#include <iostream>
#include <string>

using namespace std;

int main()
{
    string input;
    bool complete = false;
    bool hasUpper = false;
    bool hasLower = false;
    bool hasDigit = false;
    bool specialChar = false;
    int count;
    char special = 'a';


    do
    {
        cout << endl << "Enter a password to rate its strength. Enter q to quit." << endl;
        cin >> input;

        for(count =0; count < input.size(); count++)
        {
            if( islower(input[count]) )
            hasLower = true;

            if( isupper(input[count]) )
            hasUpper = true;

            if( isdigit(input[count]) )
            hasDigit = true;

            special = input.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 ");

            if (special != 'a')
            specialChar = true;
        }

        if (hasLower && hasUpper && hasDigit && specialChar && (count >= 8))
        {
            cout << "Strong" << endl;
        }
        else if((hasLower || hasUpper) && hasDigit && (count >= 6))
        {
            cout << "Moderate" << endl;
        }
        else
        { 
            cout << "Weak" << endl;
        }
        if (input == "q") complete = true; 
    }while (!complete);
    return 0;
}

Answer 1

size_t special;

if (special != string::npos)
        specialChar = true;

find_first_not_of returns the index of the found character, or the special value string::npos if no character is found.

Because find_first_not_of returns an index not a character, you must declare special as size_t not char .

Answer 2

This is more a comment on your code structure, than a direct answer to your immediate question. (If you correct the structure, the problem will disappear, however.) At present, you seem to be mixing two different solutions, in a very odd way. In particular, you're calling input.find_first_not_of each time through the loop, despite the fact that it checks all of the characters. You should choose one solution, and use it for all of the conditions.

If you want to loop, checking each characters:

for ( int count = 0; count != input.size(); ++ count ) {
    unsigned char ch = input[count];    // To avoid undefined behavior
    if ( islower( ch ) {
        hasLower = true;
    } else if ( isupper( ch ) ) {
        hasUpper = true;
    } else if ( isdigit( ch ) ) {
        hasDigit = true;
    } else {
        hasSpecial = true;
    }
}

Note that the use of if/else if means that you don't need a test for special—special is anything that doesn't meet any of the preceding tests. If you wanted a test, !isalnum( ch ) would serve the purpose just fine.

Alternatively, you can use standard functions for each:

hasLower = std::find_if(
                input.begin(),
                input.end(),
                []( unsigned char ch ) { return islower( ch ); } )
            != input.end();
hasUpper = std::find_if(
                input.begin(),
                input.end(),
                []( unsigned char ch ) { return isupper( ch ); } )
            != input.end();
hasDigit = std::find_if(
                input.begin(),
                input.end(),
                []( unsigned char ch ) { return isdigit( ch ); } )
            != input.end();
hasSpecial = std::find_if(
                input.begin(),
                input.end(),
                []( unsigned char ch ) { return !isalnum( ch ); } )
            != input.end();

The lambda functions in the above is only available in C++11. If you do not have C++11, you would have to write a separate functional object for each, which would make this solution far heavier than the simple loop above. Unless, of course, you're doing a lot of text processing, in which case, the functional objects would go in your tool kit, to be reused many times. Unless you have the functional objects ready and in your tool kit, however, this seems more complex than the simple loop, even with lambda. (On the other hand, it's more idiomatic. But then, it's hard to imagine any experienced C++ programmer without the functional objects in his toolkit.)