What is no matching function for call to 'isPalindrome'?

Question

top 35/3_palindrome.cpp:18:8: error: no matching function for call to 'isPalindrome'
    if(isPalindrome(s)){
       ^~~~~~~~~~~~
top 35/3_palindrome.cpp:4:5: note: candidate function not viable: no known conversion from 'std::__1::string' (aka 'basic_string<char,
      char_traits<char>, allocator<char> >') to 'char *' for 1st argument
int isPalindrome(char* s){
    ^
1 error generated.
The terminal process "/bin/zsh '-c', ' g++ -g 'top 35/3_palindrome.cpp' -o 3_palindrome.out && clear && ./3_palindrome.out'" terminated with exit code: 1.

My code:

#include <bits/stdc++.h>
using namespace std;

int isPalindrome(char* s){
    int n = strlen(s);
    for (int i = 0; i < n/2; i++){
        if(s[i] != s[n - i - 1]){
            return 0;
        }
    }
    return 1;
}

int main(){
    string s;
    getline(cin,s);
    cout << s;
    if(isPalindrome(s)){
        cout << "Yes";
    }
    else{
        cout << "No";
    }
    return 0;
}

Answer 1

The Problem

Your isPalindrome function expects char * for its argument. There is no suitable implicit conversion (operator or otherwise) from what you're giving it, a std::string, to that char *. The compiler is dutifully pressing on and attempting to find an alternative overload of isPalindrome that matches what you're actually feeding it. Finding none, the resulting error halts the compile and leaves you with your not-necessarily-crystal-clear error message.

A Solution

There are a multitude of solutions, but the easiest is simply to change isPalindrome to accept a reference to const std::string:

bool isPalindrome(std::string const& s)
{
    std::size_t n = s.length();
    for (std::size_t i=0; i<n/2; ++i)
    {
        if(s[i] != s[n - i - 1])
            return false;
        
    }
    return true;
}

A More-C++ Solution

All you're really doing is comparing two ranges. The standard library provides a function to do this, std::equal , which takes an iterator begin/end, and a secondary iterator starting point (and after C++14, a secondary ending point). Furthermore, the std::string class provides both fore and aft direction iterators (begin() and rbegin(), and the lot of them can be used to do this:

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

bool isPalindrome(std::string const& s)
{
    return std::equal(s.begin(), std::next(s.begin(), s.length()/2), s.rbegin());
}

Note that neither this, nor your original C-based approach, will work with mixed-case comparison. I.e. Aba will certainly not compare as a successful palindrome. More work is involved if you want that. Also, the three-argument overload of std::equal is available until, but not including, C++20, after that you need the four argument version (the second range also requires an end-iterator; not just a starting point).

Noteworthy

Neither #include <bits/stdc++.h> or using namespace std are good ideas, and should be avoided. There are woefully inadequate web sites and online "courses" that preach using both almost by reflex; just... don't. If you want know more about why these are terrible practices I urge you to read:

• Why should I not #include <bits/stdc++.h>?
• Why is “using namespace std;” considered bad practice?

Answer 2

Take a closer look at the error:

if(isPalindrome(s)){ palindrome.cpp:4:5: note: candidate function not viable: no known conversion from 'std::__1::string' (aka 'basic_string<char, char_traits, allocator >') to 'char *' for 1st argument

So let's break it down:

1- if(isPalindrome(s)){

That's the line that failed compiling. The line has an if statement, a call to the isPalindrome function, and a reference to variable s. It also has some C syntax related to those, ( ( )){. The error could be in any of those. You do have an arrow to the isPalindrome function, so that's our best bet, but not necessarily the root cause yet.

2- palindrome.cpp:4:5:

That's an offending line (or at least, a line related to your issue). What this line does,

int isPalindrome(char* s){

is just declare a function. So now we know the issue is at least related to your function declaration, confirming the suspicion above.

2- candidate function not viable:

this goes a bit more detail into what the problem with that function is.

Each function call has to be matched to a function declaration. C++ accepts (function overloading)[https://en.wikipedia.org/wiki/Function_overloading], so given a function call, the compiler will find all "candidate" functions, that is, those that have a matching name. Between those, the compiler will look at certain hints, such as the types you're passing in, to determine which implementation to use.

The error here declares that there is no viable function. So there was no function that could be matched to the call you're making.

3- *no known conversion from 'std::__1::string' [...] to 'char ' for 1st argument:

Now this is the remaining piece we need. The compiler tells you that in the best candidate function it found, for the first (and only) argument, there is a type mismatch. The function expects a char *, but the argument being used in your call can't be converted to a char *. The argument you're passing is of type std::string, and that can't be converted to a char * automatically.

There are several ways to fix this, but the easiest route is to change your types so that either the variable you pass in is a char *, or the function you're defining expects the type you're passing in, that is, std::string.

As someone mentioned above, one way to achieve this, among several others, is to just add s.c_str() to your function call, instead of purely passing in s. That is a manual conversion from std::string to char *.

In general though, converting types with manual calls isn't a good solution from a performance or maintainability standpoint. You'd be better off just reimplementing either your function or your input reading to use the same type throughout, be it std::string or char *.