Bdtjtk

I'd like to write a template function that can handle both QString and std::string in order to reduce copied code. Unfortunately, QString does not implement the substr member function. QString::mid(int, int) seems to be the Qt analogue. What is the best way to handle this discrepancy? Below is the function I have that should act on std::string-like objects:

Template function:

template <typename StringType>

void do_something(StringType s, StringType::size_type start, StringType::size_type length) {

    // Not defined if StringType == QString

    StringType sub_s = s.substr(start, length);



    // Do something with the substring, for instance:

    std::cout << "Length of substring is " << sub_s.length() << std::endl;

}

My guess is that I will need to create another function get_substr that is defined for both std::string and QString, which I can call in do_something, but I am not sure if this is the ideal solution.

Both std::string and QString have data() and size() members, so you could construct a std::basic_string_view for unified string operations:

#include <iostream>

#include <string_view>



template <typename StringType>

void do_something( StringType const& s, typename StringType::size_type start, typename StringType::size_type length ) 

{   

    std::basic_string_view sv( s.data(), s.size() );



    auto sub_s = sv.substr( start, length );



    // Do something with the substring, for instance:

    std::cout << "Length of substring is " << sub_s.length() << std::endl;

}

Live Demo

As of the time of writing this completed answer, user zett42 has given a valid solution to your problem. It took me some time to properly install Qt and to integrate it into Visual Studio 2017, since now that I have it working I am now finally able to properly build and compile my code to make sure that it works without any issues or bugs.

I think the simplest thing to do would be to use QString's toStdString() function. You can write all of your functionality with the default std::string version, and then just specialize the QString overloaded version that just calls the std::string version by converting the contents of the QString to a std::string. I will use a simple printString() function to demonstrate this in the simplest manner; you can take this approach and expand it from here.

#include <string>

#include <iostream>

#include <QString>



// defaulted std::string version (full implementation of function)

template <typename StringType>

void printString(const StringType& s) {

    std::cout << s << 'n';

}



// specialized overloaded QString version (it calls the std::string version)

template<>

void printString<QString>(const QString& s ) {

    printString(s.toStdString());

}



int main() {

    const std::string str( "I am an original std::string" );

    const QString qStr( "I am a QString converted to a std::string" );



    printString(str);

    printString(qStr);



    return 0;

}

-Output-

I am an original std::string

I am a QString converted to a std::string

I think this is the easiest way to achieve what you are asking for. This also has the advantage that if you have to make a modification to your implementation you only have to change the std::string version.