Tukukkk

I'm running into some portability problems with C++11 std::string length. On Windows it is long long unsigned int but on Linux and Mac it is long unsigned int. My understanding is that using auto is a standard approach to resolving problems like this, but I'm having some difficulty finding a portable way to expose these attributes via a class interface.

The following class compiles and runs without problems on Linux GCC 7.3.0 (and also on MacOS):

g++ -g -O2 -std=c++11 -Werror=conversion stringwrap.cc

./a.out

3

But on Windows (g++ 8.1.0 MinGW-W64 x86_64-posix-seh-rev0), I get the following compile error:

C:tempv0.11>g++ -g -O2 -std=c++11 -Werror=conversion stringwrap.cc

In file included from stringwrap.cc:1:

stringwrap.h: In function 'long unsigned int determineFirstPosition(std::__cxx11::string)':

stringwrap.h:35:20: error: conversion from 'std::__cxx11::basic_string<char>::size_type' {aka 'long long unsigned int'}

to 'long unsigned int' may change value [-Werror=conversion]

     return s.length();

            ~~~~~~~~^~

stringwrap.cc: In member function 'long unsigned int Stringwrap::length() const':

stringwrap.cc:9:23: error: conversion from 'std::__cxx11::basic_string<char>::size_type' {aka 'long long unsigned int'}

to 'long unsigned int' may change value [-Werror=conversion]

     return str_.length();

            ~~~~~~~~~~~^~

cc1plus.exe: some warnings being treated as errors

stringwrap.h

#include <iostream>

#include <string>



class Stringwrap

{

  private:

    std::string str_;



  public:



    Stringwrap(const std::string& str);



    unsigned long int length() const;



    unsigned long int getFirstPosition() const;

};



inline unsigned long int determineFirstPosition(const std::string s)

{

    for (unsigned long int i = 0; i < s.length(); ++i)

    {

        switch (s.at(i))

        {

            case ' ':

            {

                break;

            }

            default:

            {

                return i;

            }

        }

    }



    return s.length();

}

stringwrap.cc

#include "stringwrap.h"



Stringwrap::Stringwrap(const std::string& str) : str_(str)

{

}



unsigned long int Stringwrap::length() const

{

    return str_.length();

}



unsigned long int Stringwrap::getFirstPosition() const

{

    return determineFirstPosition(str_);

}



int main()

{

    Stringwrap sw = *new Stringwrap("   x   ");

    std::cout << sw.getFirstPosition() << std::endl;

}

I've tried changing all of the unsigned long ints to auto, and with -std=c++11 I get the following errors:

C:tempv0.11>g++ -g -O2 -std=c++11 -Werror=conversion stringwrap.cc

In file included from stringwrap.cc:1:

stringwrap.h:13:19: error: 'length' function uses 'auto' type specifier without trailing return type

     auto length() const;

                   ^~~~~

stringwrap.h:13:19: note: deduced return type only available with -std=c++14 or -std=gnu++14

stringwrap.h:15:29: error: 'getFirstPosition' function uses 'auto' type specifier without trailing return type

     auto getFirstPosition() const;

                             ^~~~~

stringwrap.h:15:29: note: deduced return type only available with -std=c++14 or -std=gnu++14

stringwrap.h:18:55: error: 'determineFirstPosition' function uses 'auto' type specifier without trailing return type

 inline auto determineFirstPosition(const std::string s)

                                                       ^

stringwrap.h:18:55: note: deduced return type only available with -std=c++14 or -std=gnu++14

stringwrap.h: In function 'auto determineFirstPosition(std::__cxx11::string)':

stringwrap.h:35:21: error: inconsistent deduction for auto return type: 'int' and then 'long long unsigned int'

     return s.length();

                     ^

stringwrap.cc: At global scope:

stringwrap.cc:7:27: error: 'length' function uses 'auto' type specifier without trailing return type

 auto Stringwrap::length() const

                           ^~~~~

stringwrap.cc:7:27: note: deduced return type only available with -std=c++14 or -std=gnu++14

stringwrap.cc:12:37: error: 'getFirstPosition' function uses 'auto' type specifier without trailing return type

 auto Stringwrap::getFirstPosition() const

                                     ^~~~~

stringwrap.cc:12:37: note: deduced return type only available with -std=c++14 or -std=gnu++14

When I use auto and compile --std=c++14, I get the following error:

C:tempv0.11>g++ -g -O2 -std=c++14 -Werror=conversion stringwrap.cc

In file included from stringwrap.cc:1:

stringwrap.h: In function 'auto determineFirstPosition(std::__cxx11::string)':

stringwrap.h:35:21: error: inconsistent deduction for auto return type: 'int' and then 'long long unsigned int'

     return s.length();

                     ^

Question: How can I write portable C++11 code (Linux, Windows) that avoids type conversions in STL data types like std::string (as demonstrated above)?

std::string provides public types, like std::string::size_type, that you can use to define your function. You can define your determineFirstPosition function like

inline std::string::size_type determineFirstPosition(const std::string s)

{

    for (std::string::size_type i = 0; i < s.length(); ++i)

    {

        switch (s.at(i))

        {

            case ' ':

            {

                break;

            }

            default:

            {

                return i;

            }

        }

    }



    return s.length();

}

and if you don't want to repeat std::string::size_type all over the place you can add a using declaration to your class to shorten the name like

using pos_type = std::string::size_type;

and then you would just use pos_type.

Looking at the std::string documentation, you can see the type is called

std::string::size_type

so just use that. You don't need to know or guess what primitive type it is a typedef of - you already have a useable name that is guaranteed to be correct.

c++11 cannot use auto return type deduction.

For c++14, reading your mind, you ported this:

inline unsigned long int determineFirstPosition(const std::string s)

{

    for (unsigned long int i = 0; i < s.length(); ++i)

    {

        switch (s.at(i))

        {

            case ' ':

            {

                break;

            }

            default:

            {

                return i;

            }

        }

    }



    return s.length();

}

to

inline auto determineFirstPosition(const std::string s)

{

    for (auto i = 0; i < s.length(); ++i)

    {

        switch (s.at(i))

        {

            case ' ':

            {

                break;

            }

            default:

            {

                return i;

            }

        }

    }



    return s.length();

}

in this case your error was

    for (auto i = 0; i < s.length(); ++i)

because auto i = 0 is an int, not the type of s.length().

Do

    for (decltype(s.length()) i = 0; i < s.length(); ++i)

if you want to avoid naming types here.

Alternatively, you can use std::string::size_type. Alternatively you can write an utility to let you for(:) over indexes into something;

template<class T> struct tag_t {using type=T;};



template<class X> using block_deduction = typename tag_t<X>::type;



template<class It>

struct range_t {

  It b, e;

  It begin() const { return b; }

  It end() const { return e; }

};

template<class S>

struct indexer_t {

  S s;

  void operator++(){++s;}

  S operator*() const{ return s; }

  friend bool operator==( indexer_t const& lhs, indexer_t const& rhs ) {

    return lhs.s == rhs.s;

  }

  friend bool operator!=( indexer_t const& lhs, indexer_t const& rhs ) {

    return lhs.s != rhs.s;

  }

};

template<class S>

range_t<indexer_t<S>> indexes( block_deduction<S> start, S finish ) {

  return {{std::move(start)}, {std::move(finish)}};

}

template<class C>

auto indexes_into( C&& c ) {

  return indexes( 0, c.size() );

}

all of which lets you do:

for( auto i : indexs_into(s) )

instead of

for (unsigned long int i = 0; i < s.length(); ++i)

Live example.

(as a side bonus,

template<class C>

auto iterators_into( C& c ) {

  return indexes( c.begin(), c.end() );

}

is also useful, allowing you to iterate over all valid iterators into a container without manually writing a for(;;) loop)