How to get function definition/signature as a string in Clang?

You could try using clang_Cursor_getMangling() and demangle the result in order to get the complete definition.

I'm using the following for a project I am working on and it works great for the definition. TL&DR clang_getCursorPrettyPrinted with the policy TerseOutput set to true.

    std::string getStdString(const CXString &s)
    {
        std::string rv = clang_getCString(s);
        clang_disposeString(s);
        return rv;
    }
    
    bool isFunctionImplementation(CXCursor &cursor,std::string &decl,std::string &filename,unsigned &lineno)
    {
        std::string cs = getStdString(clang_getCursorPrettyPrinted(cursor,nullptr));
        if (cs.find('{') == std::string::npos) // Just a declaration, not the "meat" of the function, so we dont care
            return false;
        clang::LangOptions lo;
        struct clang::PrintingPolicy pol(lo);
        pol.adjustForCPlusPlus();
        pol.TerseOutput = true;
        pol.FullyQualifiedName = true;
        decl = getStdString(clang_getCursorPrettyPrinted(cursor,&pol));
        CXSourceLocation location = clang_getCursorLocation( cursor );
        CXFile f;
        lineno = 0;
        filename = "(None)";
        clang_getSpellingLocation(location,&f,&lineno,nullptr,nullptr);
        if (lineno)
        {
            filename = getStdString(clang_File_tryGetRealPathName(f));
        }
        return isAllowedDirectory(filename);
    }

This one checks if the function call is "meat" or just a definition. Obviously you can adjust as needed, including writing your own isAllowedDirectory function. Just pass the cursor, two strings and an unsigned into this as you walk your AST when you hit a declaration type.

I use the following, shorter way with clang 10 (though its using a matcher, not a cursor): The 2 helper functions are general helpers to get the code snippet as a string.

// helper function 1: find position of end of token    
SourceLocation
end_of_the_end(SourceLocation const & start_of_end, SourceManager & sm)
{
  using namespace clang;
  LangOptions lopt;
  return Lexer::getLocForEndOfToken(start_of_end, 0, sm, lopt);
}

  // helper function 2: 
  std::string getSymbolString(clang::SourceManager & sm,
                              const clang::SourceRange & range)
  {
    return std::string(sm.getCharacterData(range.getBegin()),
                       sm.getCharacterData(end_of_the_end(range.getEnd(), sm)));
  }

The actual code snippet to get the function declaration string is:

// ... in run() of a matcher:
  virtual void run(corct::result_t const & result) override
  {
    using namespace clang;
    FunctionDecl * f_decl = const_cast<FunctionDecl *>(
        result.Nodes.getNodeAs<FunctionDecl>(fd_bd_name_));

    if(f_decl) {
      SourceManager & sm(result.Context->getSourceManager());
      FunctionDecl * f_decl = const_cast<FunctionDecl *>(
          result.Nodes.getNodeAs<FunctionDecl>(fd_bd_name_));
      auto full_decl_string =
          getSymbolString(sm, f_decl->DeclaratorDecl::getSourceRange());
    }
 }

This will output inline bool test2(std::string const & str, std::vector<std::string> & sss) for the following function:

  inline bool test2(std::string const & str, std::vector<std::string> & sss)
  {
    return true;
  }