Is it possible to write one function for std::string and std::wstring?

Question

I just wrote a simple utility function for std::string. Then I noticed that the function would look exactly the same if the std::string was a std::wstring or a std::u32string. Is it possible to use a template function here? I am not very familiar with templates, and std::string and std::wstring are templates themselves, which might be an issue.

template<class StdStringClass>
inline void removeOuterWhitespace(StdStringClass & strInOut)
{
  const unsigned int uiBegin = strInOut.find_first_not_of(" \t\n");

  if (uiBegin == StdStringClass::npos)
  {
    // the whole string is whitespace
    strInOut.clear();
    return;
  }

  const unsigned int uiEnd   = strInOut.find_last_not_of(" \t\n");
  strInOut = strInOut.substr(uiBegin, uiEnd - uiBegin + 1);
}

Is this a proper way to do it? Are there pitfalls with this idea. I am not talking about this function but the general concept of using a templated class StdStringClass and calling the usual std::string functions like find, replace, erase, etc.

I see nothing particulary wrong. For me, our template seems good. No problem for using some specific function. It just not compile if you give a parameter which haven't used function inside template — Garf365
– Garf365, Commented Mar 3, 2016 at 9:15
find and replace will require some trickery, since the character types are different. For example, the function above would not work for std::wstring, because std::wstring::find_first_not_of does not take a const char*, but a const wchar_t*. — Benjamin Lindley
– Benjamin Lindley, Commented Mar 3, 2016 at 9:31
Seem's fine for me either except instead of unsigned int i would recommend use typename StdStringClass::size_type or auto if c++11 is enabled. — Radek
– Radek, Commented Mar 3, 2016 at 9:31
@Benjamin Maybe the searched string " \t\n" should be wrapped to StdStringClass(" \t\n"), does it solves that? — Radek
– Radek, Commented Mar 3, 2016 at 9:34
@Radek: No, because that would try to call a constructor that doesn't exist for wstring. — Benjamin Lindley
– Benjamin Lindley, Commented Mar 3, 2016 at 9:35

David Haim · Accepted Answer · 2016-03-03 09:46:51Z

6

Its a good Idea, But I'd build the template on top of std::basic_string rather then general StdStringclass

template<class T>
inline void removeOuterWhitespace(std::basic_string<T>& strInOut)
{
  constexpr auto delim[] = {T(' '),T('\t'),T('\n'),T(0)};
  const auto uiBegin = strInOut.find_first_not_of(delim);

  if (uiBegin == std::basic_string<T>::npos)
  {
    // the whole string is whitespace
    strInOut.clear();
    return;
  }

  const auto  uiEnd   = strInOut.find_last_not_of(delim);
  strInOut = strInOut.substr(uiBegin, uiEnd - uiBegin + 1);
}

I would also ditch the MSDN-style "inout" notation in favro for simpler name like str. programmer will guess themselves that str is the result since it is passed as non-const reference and function returns void.

also, I changed unsigned int to auto. all the standard C++ containers/strings return size_t when returning indexes. size_t might not be unsigned int. auto matches itself to the right return value.

edited Mar 3, 2016 at 9:46

answered Mar 3, 2016 at 9:31

David Haim

26.7k4 gold badges50 silver badges88 bronze badges

Sign up to request clarification or add additional context in comments.

7 Comments

Fabian Over a year ago

Is T(0) supposed to be T(' ')?

David Haim Over a year ago

it's supposed to be the null terminator. looking again I forgot the whitespace, I'll add it

Fabian Over a year ago

I see. Very good answer. Unfortunately, C++11 is not available to me. I hope to be able to circumvent auto. The gcc compiler complained when I use size_t some time ago, hence I switched to unsigned int.

David Haim Over a year ago

you can still do it with C++03. the instead of constexpr auto... just write const T and std::basic_string<T>::size_type for the rest

rubenvb Over a year ago

I'd advise against using basic_string here explicitly, and for one very good reason: what if I later switch to some alternative string class that provides the interface I used here? I'd use a typename StringType and use StringType::value_type to get at its underlying character type. That being said, it might be better to use some form of isspace predicate instead of a hardcoded list of whitespace. Especially if things like wstring are used (implying more-than-only-ASCII whitespace characters).

|

Adl A · Accepted Answer · 2016-03-03 10:48:37Z

-1

Assuming your template works as expected (haven't checked...sorry), another option would be to wrap the function in class, and control which types of strings classes you'd like the function to be applied to using constructors.

EDIT: added illustrative framework

EDIT2 one that compiles (at least with vs2015) :-)

class StringType1;
class StringTypeN;

class str {

    //template function
    template<class StdStringClass>
    inline void removeOuterWhitespace(StdStringClass & strInOut)
    {
        //.
        //.
        //.
    }

public:
    //constructors
    str(StringType1 &s1) { removeOuterWhitespace(s1); }
    //.
    //.
    //.
    str(StringTypeN &sN) { removeOuterWhitespace(sN); }


};

int main() {

    return 0;
}

EDIT3 Proof of concept

#include <iostream>
class incr {
    //template function
    template<class incrementor>
    inline void removeOuterWhitespace(incrementor & n)
    {
        n++;
    }
public:
    //constructors
    incr(int &n1) { removeOuterWhitespace(n1); }
    incr(double &n1) { removeOuterWhitespace(n1); }
    incr(float &n1) { removeOuterWhitespace(n1); }
};

int main() {
    int n1 = 1;
    double n2 = 2;
    float n3 = 3;
    std::cout << n1 << "\t" << n2 << "\t" << n3 << std::endl;
    auto test1 = incr(n1);
    auto test2 = incr(n2);
    auto test3 = incr(n3);
    //all variables modified
    std::cout << "all variables modified by constructing incr" << std::endl;
    std::cout << n1 << "\t" << n2 << "\t" << n3 << std::endl;
    return 0;
}

edited Mar 3, 2016 at 10:48

answered Mar 3, 2016 at 9:33

Adl A

1831 silver badge8 bronze badges

8 Comments

Revolver_Ocelot Over a year ago

Please elaborate further and add some code to illustrate your answer. Rght now it is not a helpful answer, as it does not provide a definitive solution to OP problem.

Fabian Over a year ago

Assuming I understand you correctly, I do not see how this would reduce the code duplication. In the class, I would still need to implement the above code for each type of string. My aim is to stick to the DRY principle. Using one template method seems much more elegant to me.

Adl A Over a year ago

Fabian, @Revolver_Ocelot , I edited the answer and added illustrative code. Fabian, yes i know there is some extra code, but the benefit is that you gain control. cheers!

Revolver_Ocelot Over a year ago

(1) This code will not compile (syntax errors, there is no actual function call in constructor) (2) How this is better than simply calling templated function?

Adl A Over a year ago

@Revolver_Ocelot it is not better , it simply adds control, for whenever you might want to avoid runtime errors.

|

Collectives™ on Stack Overflow

Is it possible to write one function for std::string and std::wstring?

2 Answers 2

7 Comments

8 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

7 Comments

8 Comments

Your Answer

Sign up or log in

Post as a guest

Related