# Check if a string is alphanumeric in C++

In this article, we will learn how to check whether a string is alphanumeric or not in C++.

## Problem Description

Our C++ program takes the string as input from the user, and it will iterate through the characters of the string and check whether it contains only alphanumeric characters or not.

Input

```string str = "thisPointer999"
```

Output

```The string is alphanumeric.
```
• If the given string contains only an alphanumeric character, then we have to print The string is alphanumeric.
• If the given string contains any non-alphanumeric character, then we have to print The string is non-alphanumeric.

We can think of solving the given problem in four ways. Let’s understand all the approaches in details one by one.

## Check if string is alphanumeric using std::count_if()

The first approach we will learn is the standard template library algorithm `std::count_if()` function. The `count_if()` function accepts a range and a callback function (predicate) as arguments. It applies the given function to all elements of the range. This range is the input iterators pointing to the starting and ending position of the string. The range used is `[start, end)`, which contains all the elements between start and end, including the element pointed by `start` but not the element pointed by the `end`. The `count_if()` function returns the number of elements in the range `[start,end)` for which predicate is true.

We can pass all characters of string as range and `isalnum()` function, as arguments to the `count_if()` function. It will call the `isalnum()` function on each of the characters, to confirm if it is an alphanumeric character or not. So, the `count_if()` function counts the number of elements for which the `isalnum()` is true in the range`[start,end)`. If the count value is equal to the length of the string, that means all the characters of the string are alphanumeric, and hence string is alphanumeric.

• Time Complexity is of an order of n means linear. It is the range between first and last, comparing pairs of elements until a mismatch is identified. Time Complexity O(n).
• Space Complexity is also of order 1 means constant. Space Complexity O(1).

Let’s see the practical example,

```#include <iostream>
#include <string>
#include <algorithm>

int main()
{
std::string str = "thisPointer999";

// Get count of alphanumeric characters in string
int count = std::count_if(
std::begin(str),
std::end(str),
::isalnum);

// Check if count of alphanumeric characters in string
// is equal to the length of string
if(count == str.length())
{
std::cout << "The string is alphanumeric.\n";
}
else{
std::cout << "The string is non-alphanumeric.\n";
}

return 0;
}
```

Output

```The string is alphanumeric.
```

## Check if string is alphanumeric using std::all_of()

The second approach we will learn is the standard template library algorithm `std::all_of()` function. It accepts a range and a callback function (predicate) as arguments. It applies the given function to all elements of the range. This range is the input iterators pointing to the starting and ending position of the string. The range used is `[start, end)`, which contains all the elements between start and end, including the element pointed by start but not the element pointed by the end. If the function/predicate returns true for all the elements, then only `all_of()` function will return true. Otherwise, the `all_of()` will return false. Also, if the range is empty, then it also returns false.

We can pass all characters of string as range and `isalnum()` function as arguments to the `all_of()` function. It will call the 1 function on each of the characters to confirm if it is an alphanumeric character or not. If `all_of()` finds any character for which `isalnum()` returns false, it will return false. Otherwise, it will return true. If `all_of()` returns true, that means all the characters of the string are alphanumeric, and hence string is alphanumeric.

• Time Complexity is of an order of n means linear. It is the range between first and last, comparing pairs of elements until a mismatch is identified. Time Complexity O(n).
• Space Complexity is also of order 1 means constant. Space Complexity O(1).

Let’s see the practical example,

```// Using std::all_of() to check whether a string is alphanumeric or not
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

int main()
{
string str = "thisPointer199";

// Iterating from beginning of the string to end of the string

bool isalphaNumeric = all_of(begin(str), end(str),::isalnum);

if(isalphaNumeric)
{
cout << "The string is alphanumeric.\n";
}
else
{
cout << "The string is non-alphanumeric.\n";
}
return 0;
}
```

Output

```The string is alphanumeric.
```

## Check if string is alphanumeric using std::find_if_not()

The third approach we will learn is the standard template library algorithm std::find_if_not() function. The find_if_not() function accepts a range and a callback function (predicate) as arguments. It applies the given function to all elements of the range. This range is the input iterators pointing to the starting and ending position of the string. The range used is [start, end), which contains all the elements between start and end, including the element pointed by start but not the element pointed by the end. The find_if_not() function returns the iterator in the range [start,end) for which predicate is false.

We can pass all characters of string as range and isalnum() function as arguments to the find_if_not() function. We will call the isalnum() function on each of the characters to confirm if it is an alphanumeric character or not. So, the find_if_not() function return an iterator for which isalnum() is false in the range [start,end). If the iterator returned by the find_if_not() function equals the end of the string, that means all the characters of the string are alphanumeric, and hence string is alphanumeric.

• Time Complexity is of an order of n means linear. It is the range between first and last, comparing pairs of elements until a mismatch is identified. Time Complexity O(n).
• Space Complexity is also of order 1 means constant. Space Complexity O(1).

Let’s see the practical example,

```// Using std::find_if_not() to check whether a string is alphanumeric or not
#include <iostream>
#include <string>
#include <algorithm>

using namespace std;

int main()
{
string str = "thisPointer909";

// Iterating from beginning of the string to end of the string
bool isalphaNumeric = find_if_not(
begin(str),
end(str),
::isalnum) == str.end();

if(isalphaNumeric)
{
cout << "The string is alphanumeric.\n";
}
else
{
cout << "The string is non-alphanumeric.\n";
}

return 0;
}
```

Output

```The string is alphanumeric.
```

## Check if string is alphanumeric using std::isalnum()

The fourth and last approach we will learn is the standard template library algorithm std::isalnum(). It takes one character at a time and checks whether it is alphanumeric or not. So we use this in our program to count the number of characters for which the isalnum() function is false. If the count is equal to or greater than 1, then it indicates that the string has some non-alphanumeric characters; hence, the given string is non-alphanumeric. Otherwise, if the count is equal to zero, it indiactes that the string has alphanumeric characters, and therefore the given string is alphanumeric.

• Time Complexity is of an order of n means linear. It is the range between first and last, comparing pairs of elements until a mismatch is identified. Time Complexity O(n).
• Space Complexity is also of order 1 means constant. Space Complexity O(1).

Code example,

```// Using std::isalnum() to check whether a string is alphanumeric or not
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

int main()
{
string str = "thisPointer999";

// Iterating from beginning of the string to end of the string

int count=0;
for (const char& ch: str)
{
if (!isalnum(ch))
{
count++;
}
}

if(count)
{
cout << "The string is non-alphanumeric.\n";
}
else{
cout << "The string is alphanumeric.\n";
}

return 0;
}
```

Output

```The string is alphanumeric.
```

## Summary

We have seen a detailed explanation of four approaches to checking whether the string is alphanumeric or not. The first one is using the std::count_if(), second is std::all_of(), third one is std::find_if_not() , and the last is using std::isalnum(). Also, we have seen the Time and Space Complexity of all four approaches. Thanks.