A>>std::vector<std::string> split(const std::string &s, char delim) {
A>>    std::vector<std::string> elems;
A>>    split(s, delim, elems);
Aё> ====>>>> Copy constructor !!!
A>>    return elems;
A>>}

A>>

real    0m0.007s
user    0m0.002s
sys    0m0.003s

typedef boost::iterator_range<std::string::const_iterator> string_view;

std::vector<std::string> parts;

std::vector<string_view> parts;

Under the following circumstances, the compilers are permitted to omit the copy- and move-constructors of class objects even if copy/move constructor and the destructor have observable side-effects.

struct parser{


 char* parse(char* p, const char* s, char* pp) const {
  
  char *tmp=p; size_t sz=0, len=strlen(s);
   
 do{
while(*p <45 || *p >122){ if(p==pp) return NULL; ++p; };
  tmp=p; sz=0;
while(*p > 44 &&  *p < 123){ if(p==pp) return NULL; ++p; ++sz;};
   if(sz!=len) continue;
   if(strncmp(tmp, s, sz)==0){ 
while(*p <45 || *p >122){ if(p==pp) return NULL; ++p; }; tmp=p;
while(*p > 44 &&  *p < 123){ ++p;  }; *p='\0'; return tmp;
       };

  }while(1);  
 };


template <typename T>
void parse_array(char* p, T* vec, char* pp){

 size_t sz=0; char* tmp;
do{ if(p==pp && *p=='}')  return; 
   while(*p <45 || *p >122){  ++p; if(p==pp || *p=='}')  return; }; tmp=p;
    while(*p > 44 &&  *p < 123){ if(p==pp)  return; ++p; }; *p='\0'; vec[sz]=cast(tmp, vec+sz); ++sz;
     
       }while(1);
    
  };

template <typename T>
T cast(char* s, T* p){   if(typeid(p[0])==typeid(float)){ return std::stof(s); }else{ return std::stoi(s); }; }; 

  };

#include <string>
#include <vector>
#include <sstream>
#include <fstream>

using namespace std;

std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
    std::stringstream ss(s);
    std::string item;
    while (std::getline(ss, item, delim)) {
        elems.push_back(item);
    }
    return elems;
}

std::vector<std::string> split(const std::string &s, char delim) {
    std::vector<std::string> elems;
    split(s, delim, elems);
    return elems;
}

int main()
{
    std::ifstream f;
    f.open("test.csv");

    std:string s;
    std::vector<std::string> sv;

    while ( std::getline(f, s) )
    {
        sv = split(s, ';');
    }

    return 0;
}

real    0m18.429s
user    0m15.919s
sys    0m0.259s

with open("test.csv", "r") as f:
    for line in f:
        s = line.split(";")

real    0m4.029s
user    0m3.346s
sys    0m0.124s

#include "stdafx.h"
#include "string.h"


int _tmain(int argc, _TCHAR* argv[])
{
    char str[] ="- This, a sample string.";
    char * pch;
    printf ("Splitting string \"%s\" into tokens:\n",str);
    pch = strtok (str," ,.-");
    while (pch != NULL)
    {
        printf ("%s\n",pch); 
        pch = strtok (NULL, " ,.-");
    }
    return 0;
}

auto split(const char* s, const char* e, char d)
{
    vector<pair<const char*, const char*>> r;
    for(const char* c=s; c!=e; ++c) if(*c==d){
        r.emplace_back(s, c);
        s=c+1;
    }
    return r;
}
int main()
{
    mapped_file_source file("test.csv");
    for(auto l: split(file.data(), file.data()+file.size(), '\n'))
        auto s=split(l.first, l.second, ';');
    return 0;
}

A>real    0m0.007s
A>user    0m0.002s
A>sys    0m0.003s
A>

real    0m12.807s
user    0m11.407s
sys    0m0.201s

std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
    std::stringstream ss(s);
    std::string item;
    while (std::getline(ss, item, delim)) {
        elems.push_back(item);
    }
    return elems; /* вот это вообще зачем не понятно? */

 std::vector<std::string> & split(const std::string &s, char delim, std::vector<std::string> &elems) {
std::stringstream ss;
std::string item;
ss.rdbuf()->pubsetbuf(const_cast<char*>(s.c_str()), ss.size());
 while (std::getline(ss, item, delim)) {
        elems.push_back(item);
  return elems;
   }

error: expected constructor, destructor, or type conversion before '(' token

real    0m11.934s
user    0m10.424s
sys    0m0.186s

#include <string>
#include <vector>
#include <sstream>
#include <fstream>

using namespace std;

std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
    std::stringstream ss(s);
    std::string item;
    for (int i = 0; std::getline(ss, item, delim); i++)
        elems[i] = std::move(item);
    return elems;
}

int main()
{
    std::ifstream f;
    f.open("test.csv");

    std:string s;
    std::vector<std::string> sv(201);

    while ( std::getline(f, s) )
        split(s, ';', sv);

    return 0;
}

real    0m3.087s
user    0m2.569s
sys    0m0.081s

man time 1

int main()
{
    std::ifstream f;
    f.open("test.csv");

    std:string s;
    std::vector<std::string> sv(201);
    std::stringstream ss;
    std::string item;

    while ( std::getline(f, s) )
    {
        ss.clear();
        ss.str(s);
        for (int i = 0; std::getline(ss, item, ';'); i++)
            std::swap(sv[i], item);
    }

    return 0;
}

real    0m2.965s
user    0m2.564s
sys    0m0.104s

char * __cdecl strtok (
        char * string,
        const char * control
        )
#endif  /* _SECURE_VERSION */
{
        unsigned char *str;
        const unsigned char *ctrl = control;

        unsigned char map[32];
        int count;

#ifdef _SECURE_VERSION

        /* validation section */
        _VALIDATE_RETURN(context != NULL, EINVAL, NULL);
        _VALIDATE_RETURN(string != NULL || *context != NULL, EINVAL, NULL);
        _VALIDATE_RETURN(control != NULL, EINVAL, NULL);

        /* no static storage is needed for the secure version */

#else  /* _SECURE_VERSION */

        _ptiddata ptd = _getptd();

#endif  /* _SECURE_VERSION */

        /* Clear control map */
        for (count = 0; count < 32; count++)
                map[count] = 0;

        /* Set bits in delimiter table */
        do {
                map[*ctrl >> 3] |= (1 << (*ctrl & 7));
        } while (*ctrl++);

        /* Initialize str */

        /* If string is NULL, set str to the saved
         * pointer (i.e., continue breaking tokens out of the string
         * from the last strtok call) */
        if (string)
                str = string;
        else
                str = _TOKEN;

        /* Find beginning of token (skip over leading delimiters). Note that
         * there is no token iff this loop sets str to point to the terminal
         * null (*str == '\0') */
        while ( (map[*str >> 3] & (1 << (*str & 7))) && *str )
                str++;

        string = str;

        /* Find the end of the token. If it is not the end of the string,
         * put a null there. */
        for ( ; *str ; str++ )
                if ( map[*str >> 3] & (1 << (*str & 7)) ) {
                        *str++ = '\0';
                        break;
                }

        /* Update nextoken (or the corresponding field in the per-thread data
         * structure */
        _TOKEN = str;

        /* Determine if a token has been found. */
        if ( string == str )
                return NULL;
        else
                return string;
}

 template<typename _Tp, typename _Alloc>
89  template<typename... _Args>
90  void
91  vector<_Tp, _Alloc>::
92  emplace_back(_Args&&... __args)
93  {
94  if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
95  {
96  _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
97  std::forward<_Args>(__args)...);
98  ++this->_M_impl._M_finish;
99  }
100  else
101  _M_emplace_back_aux(std::forward<_Args>(__args)...);
102  }
103 #endif
104

template<typename _Tp, typename _Alloc>
402  template<typename... _Args>
403  void
404  vector<_Tp, _Alloc>::
405  _M_emplace_back_aux(_Args&&... __args)
406  {
407  const size_type __len =
408  _M_check_len(size_type(1), "vector::_M_emplace_back_aux");
409  pointer __new_start(this->_M_allocate(__len));
410  pointer __new_finish(__new_start);
411  __try
412  {
413  _Alloc_traits::construct(this->_M_impl, __new_start + size(),
414  std::forward<_Args>(__args)...);
415  __new_finish = 0;
416 
417  __new_finish
418  = std::__uninitialized_move_if_noexcept_a
419  (this->_M_impl._M_start, this->_M_impl._M_finish,
420  __new_start, _M_get_Tp_allocator());
421 
422  ++__new_finish;
423  }
424  __catch(...)
425  {
426  if (!__new_finish)
427  _Alloc_traits::destroy(this->_M_impl, __new_start + size());
428  else
429  std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
430  _M_deallocate(__new_start, __len);
431  __throw_exception_again;
432  }
433  std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
434  _M_get_Tp_allocator());
435  _M_deallocate(this->_M_impl._M_start,
436  this->_M_impl._M_end_of_storage
437  - this->_M_impl._M_start);
438  this->_M_impl._M_start = __new_start;
439  this->_M_impl._M_finish = __new_finish;
440  this->_M_impl._M_end_of_storage = __new_start + __len;
441  }
442 #endif
443

__uninitialized_move_if_noexcept_a(_InputIterator __first,
295  _InputIterator __last,
296  _ForwardIterator __result,
297  _Allocator& __alloc)
298  {
299  return std::__uninitialized_copy_a
300  (_GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__first),
301  _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__last), __result, __alloc);
302  }
303

template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
275  inline _ForwardIterator
276  __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
277  _ForwardIterator __result, allocator<_Tp>&)
278  { return std::uninitialized_copy(__first, __last, __result); }
279

 inline _ForwardIterator
107  uninitialized_copy(_InputIterator __first, _InputIterator __last,
108  _ForwardIterator __result)
109  {
110  typedef typename iterator_traits<_InputIterator>::value_type
111  _ValueType1;
112  typedef typename iterator_traits<_ForwardIterator>::value_type
113  _ValueType2;
114 #if __cplusplus < 201103L
115  const bool __assignable = true;
116 #else
117  // trivial types can have deleted assignment
118  typedef typename iterator_traits<_InputIterator>::reference _RefType;
119  const bool __assignable = is_assignable<_ValueType1, _RefType>::value;
120 #endif
121 
122  return std::__uninitialized_copy<__is_trivial(_ValueType1)
123  && __is_trivial(_ValueType2)
124  && __assignable>::
125  __uninit_copy(__first, __last, __result);
126  }
127

template<bool _TrivialValueTypes>
64  struct __uninitialized_copy
65  {
66  template<typename _InputIterator, typename _ForwardIterator>
67  static _ForwardIterator
68  __uninit_copy(_InputIterator __first, _InputIterator __last,
69  _ForwardIterator __result)
70  {
71  _ForwardIterator __cur = __result;
72  __try
73  {
74  for (; __first != __last; ++__first, ++__cur)
75  std::_Construct(std::__addressof(*__cur), *__first);
76  return __cur;
77  }
78  __catch(...)
79  {
80  std::_Destroy(__result, __cur);
81  __throw_exception_again;
82  }
83  }
84  };
85

 template<typename _T1, typename... _Args>
73  inline void
74  _Construct(_T1* __p, _Args&&... __args)
75  { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
76 #else
77  template<typename _T1, typename _T2>
78  inline void
79  _Construct(_T1* __p, const _T2& __value)
80  {
81  // _GLIBCXX_RESOLVE_LIB_DEFECTS
82  // 402. wrong new expression in [some_]allocator::construct
83  ::new(static_cast<void*>(__p)) _T1(__value);
84  }
85