template <class C, class S, class P>
inline void split(C & c, const S & str, P & is_delimiter)
{
    bool next_token = false;
    typename S::const_iterator it = str.begin(), end = str.end(), token_start = it;
    for(; it != end; ++it)
    {
        if (next_token)
        {
            next_token = false;
            token_start = it;
        }
        if (is_delimiter(*it))
        {
            if (token_start != it)
                c.push_back(S(token_start, it));
            next_token = true;
        }
    }
    if (!next_token && (token_start != it))
        c.push_back(S(token_start, it));
}

inline bool is_space(const char c)
{
    return c == ' ';
}

int main()
{
    int r = 0;

    vector<string> tokens(5);
    string str("123 345 asdf 23453 asdfas");

    for(int i = 0; i < 1000000; ++i)
    {
        tokens.erase(tokens.begin(),tokens.end());
        split(tokens, str, is_space);
        r += tokens.size();
    }

    cout << r << endl;
    return 0;
}

template <class C, class S, class P>
inline void split(C & c, const S & str, P & is_delimiter)
{
    typename S::const_iterator it = str.begin(), token_start = it, end = str.end();
    for(; it != end; ++it)
    {
        if (is_delimiter(*it))
        {
            if (token_start != it)
                c.push_back(S(token_start, it));
            ++(token_start = it);
        }
    }
    if (token_start != it)
        c.push_back(S(token_start, it));
}

void my_split(vector<char*> &res, char *str, const char separator[])
{
    char *token = strtok( str, separator );

    while( token != NULL )
    {    
        res.push_back( token );
        token = strtok( NULL, separator );
    }
}

FR>REBOL [] res: 0
FR>probe loop 1000000 [res: res + length? parse "123 345 asdf 23453 asdfas" { }]
FR>

FR>3.6 секунды

do[1000000;&"123 345 asdf 23453 asdfas"=" "]

АХ>#include <vector>
АХ>#include <string>
АХ>#include <iostream>
АХ>#include <boost/algorithm/string/split.hpp>
АХ>#include <boost/algorithm/string/classification.hpp>

АХ>#include <windows.h> // for GetTickCount

АХ>using namespace std;
АХ>using namespace boost::algorithm;

АХ>int main()
АХ>{
АХ>  DWORD start = GetTickCount();
    
АХ>  int res = 0;
АХ>  for(int i = 0; i < 1000000; i++)
АХ>  {
АХ>    // так корректней сравнивать, ведь в др программах мы размер не указывали
АХ>    // + по моим тестам почти не повлияло на скорость
/*
Нет. Так сравнивать некорректно, потому что в других языках массивы могут быть 
реализованы как деки (std::deque) или списки (std::list). std::vector всегда реалочится при увеличении размера, а, например, питоновские «массивы» на самом деле списки, 
поэтому, операции конкатенации для них выполняются гааараздо быстрее. 
Правильнее было бы использовать std::list.
*/
АХ>    vector<string> tokens; 

//
АХ>    split(tokens, "123 345 asdf 23453 asdfas", is_any_of(" "));
АХ>    res += tokens.size();
АХ>  }

АХ>  DWORD stop = GetTickCount();

АХ>  cout << "res is " << res << ',' << stop - start << " ms elapsed\n";
  
АХ>  return 0;
АХ>}
АХ>

#include <list>
#include <string>
#include <iostream>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>

#define OS_POSIX

#ifdef OS_WINDOWS
#include <windows.h> // for GetTickCount
#else // posix
#include <sys/times.h>
#endif

using namespace std;
using namespace boost::algorithm;

int main()
{
#ifdef OS_WINDOWS
  DWORD start = GetTickCount();
#else
struct tms t;
  clock_t start = times(&t);
#endif
    
  int res = 0;
  for(int i = 0; i < 1000000; i++)
  {
    list<string> tokens; 
    split(tokens, "123 345 asdf 23453 asdfas", is_any_of(" "));
    res += tokens.size();
  }


#ifdef OS_WINDOWS
  DWORD stop = GetTickCount();
#else
  clock_t stop = times(&t);
#endif

  cout << "res is/ " << res << ',' << stop - start << " ms elapsed\n";
  
  return 0;
}

#include <deque>
#include <string>
#include <iostream>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>

#ifdef OS_WINDOWS
#include <windows.h> // for GetTickCount
#else // posix
#include <sys/times.h>
#endif

using namespace std;
using namespace boost::algorithm;

int main()
{
#ifdef OS_WINDOWS
  DWORD start = GetTickCount();
#else
struct tms t;
  clock_t start = times(&t);
#endif
    
  int res = 0;
  for(int i = 0; i < 1000000; i++)
  {
    // так корректней сравнивать, ведь в др программах мы размер не указывали
    // + по моим тестам почти не повлияло на скорость
    deque<string> tokens; 
    split(tokens, "123 345 asdf 23453 asdfas", is_any_of(" "));
    res += tokens.size();
  }

 #ifdef OS_WINDOWS
  DWORD stop = GetTickCount();
#else
  clock_t stop = times(&t);
#endif

  cout << "res is " << res << ',' << stop - start << " ms elapsed\n";
  
  return 0;
}

module Main where

import System.CPUTime (getCPUTime)

{- меня заленило лезть в документацию и искать функцию аналогичную split,
   поэтому я реализовал её сам. -}
split :: (a -> Bool) -> [a] -> [[a]]
split _ [] = []
split p l  = case break p l
             of { (b, [])     -> [b]
                ; ([], _)     -> [[]]
                ; (b, (e:[])) -> [b]
                ; (b, (e:ex)) -> b : (split p ex)
                }

fun :: Int -> Int
fun = fun' 0
    where
    fun' :: Int -> Int -> Int
    fun' l n | n <= 0 = l
             | otherwise 
                 = fun'
                   {- следующая строка вычисляется только 1 раз, 
                      в качестве первого аргумента функции fun' 
                      всегда передается одно и тоже значение. -}
                   (l + (length (split (==' ') "123 345 asdf 23453 asdfas"))) 
                   (n - 1)
       
main :: IO ()
main = do { begin <- getCPUTime
          ; putStr "Res is "
          ; (putStr . show . fun) 1000000
          ; putStr ", "
          ; end <- getCPUTime
          ; (putStr . show) (((fromInteger (end - begin)) :: Double) / (1000000000 :: Double))
          ; putStrLn " ms. elapsed."
          }

fun :: Int -> Int
fun = fun' 0
    where
    fun' :: Int -> Int -> Int
    fun' l n | n <= 0 = l
             | otherwise 
                 = fun'
                   (l +
                   {- следующая строка вычисляется только 1 раз, 
                      в качестве первого аргумента функции fun' 
                      всегда передается одно и тоже значение. -}
                      (length (split (==' ') "123 345 asdf 23453 asdfas"))) 
                   (n - 1)

from time import clock

t1 = clock()
print len(("123 345 asdf 23453 asdfas " * 1000000).split(" "))
t2 = clock()

print t2 - t1

from time import clock

t1 = clock()
print sum([len("123 345 asdf 23453 asdfas".split(" "))] * 1000000)
t2 = clock()

print t2 - t1