(C++) error: invalid conversion from ‘char’ to ‘const char*’ [-fpermissive] - c++

Question

I'm trying to write a function that would return a substring from the given start and end indices. This is the code that I've written but when i run it it gives me error. I'm using gtest to run it not main().
template <typename S>
S substring(S string_, int Istart, int Iend)
{
S substr = string_[Istart];
for(int i=(Istart+1); i<Iend; i++)
{
substr += string_[i];
}
return substr;
}
And this is the error i get:
In file included from test.cpp:2:0:
lab2.cpp: In instantiation of ‘S substring(S, int, int) [with S = const char*]’:
test.cpp:56:1: required from here
lab2.cpp:91:23: error: invalid conversion from ‘char’ to ‘const char*’ [-fpermissive]
S substr = string_[Istart];
~~~~~~~^
My test code is this:
TEST(subStr, T1){
string str="he";
EXPECT_EQ(str,substring("hello", 0, 2));
}
TEST(subStr, T2){
string str="urge";
EXPECT_EQ(str,substring("hamburger", 4, 8));
}

Answer 1

With the given calling context, this:
EXPECT_EQ(str,substring("hello", 0, 2));
utilizes an expansion of
substring<const char*>
and therefore the resulting code becomes:
const char* substring(const char* string_, int Istart, int Iend)
{
const char* substr = string_[Istart];
for(int i=(Istart+1); i<Iend; i++)
{
substr += string_[i];
}
return substr;
}
Clearly that's not going to work. const char* substr = string_[Istart]; is initializing const char * from char. As I see it you have two choices, but only one of them remotely realistic. Since EXPECT_EQ tests equivalence, going the pointer route will not work no matter what. You need to have a comparable std::string guaranteed on at least one side of that test, and the only way to guarantee that whilst still affording your expressive arguments is like this:
template<class S>
std::string substring(S s, int Istart, int Iend)
{
return std::string(s).substr(Istart, Iend - Istart);
}
This will take anything compatible to std::string as a source argument. The result is ALWAYS a std::string, which can then be used in comparison against a variety of things, including char[N], const char *, and of course, std::string.
It still has a huge caveat, that being Istart and Iend must be ordered. Eliminating that frailty is the very reason the standard library substr member of std::string doesn't take a begin,end; it takes a begin,length. Nonetheless, this is easily the simplest way to do what you want.(the single-line nature calling out the very usefulness of such a thing notwithstanding).
Example
I don't have GoogleTest, but a simple assert macro will demonstrate testing against different comparisons to std::string will work:
#include <iostream>
#include <string>
#include <cassert>
template<class S>
std::string substring(S s, int Istart, int Iend)
{
return std::string(s).substr(Istart, Iend - Istart);
}
int main()
{
const char *kvalptr = "welcome";
std::string kvalstr = kvalptr;
auto res = substring("abdwelcomedef", 3, 10);
// test that both lhs prospects test against our result
assert(kvalptr == res);
assert(kvalstr == res);
// output res and one of the prospects.
std::cout << res << '\n' << kvalptr << '\n';
}
Output
welcome
welcome

Answer 2

Assuming that the intended type is string. A += operator exists for the string type.
A simple fix is to replace
S substr = string_[Istart];
with
S substr;
substr += string_[Istart];
which will not work for const char* types as pointed out
The following works for both string and const char*.
#include <exception>
#include <iostream>
#include <functional>
#include <string>
#include <type_traits>
template <typename S>
S substring(S string_, int Istart, int Iend)
{
if constexpr (std::is_same_v<S, std::string>) {
if(Istart < Iend){
return string_.substr(Istart, Iend-Istart);
}
}
else if constexpr (std::is_same_v<S, const char*>)
{
if(Istart < Iend){
std::string temp = std::string(string_);
return (temp.substr(Istart, Iend-Istart)).c_str();
}
}
else throw;
}