int r = 0;

vector<string> tokens(5);

for(int i = 0; i < 1000000; i++)
{
    split(tokens, "123 345 asdf 23453 asdfas", is_any_of(" "));
    r += tokens.size();
}

int res = 0;
    
for(int i = 0; i < 1000000; i++)
    res += "123 345 asdf 23453 asdfas".Split(' ').Length;
            
Console.WriteLine(res);

split(tokens, "123 345 asdf 23453 asdfas", is_any_of(' '));

r = 0
for i in xrange(1000000):
    r += len("123 345 asdf 23453 asdfas".split(" "))
    
print r

FR>>r = 0
FR>>for i in xrange(1000000):
FR>>    r += len("123 345 asdf 23453 asdfas".split(" "))
    
FR>>print r 
FR>>

FR>>отрабатывает за 2.5 секунды

using System;

class MainApp 
{
    public static void Main() 
    { 
        int res = 0;
    
        for(int i = 0; i < 1000000; i++)
            res += "123 345 asdf 23453 asdfas".Split(' ').Length;
            
        Console.WriteLine(res);
    }
}

Samples     Address        Code Bytes             Instruction                  Symbol      CPU 0     
10          0x7c902f10     0x 0B C0               or eax,eax                   tan+210     10        
20          0x7c902f12     0x 74 0C               jz $+0eh (0x7c902f20)        tan+212     20        
29          0x7c902f14     0x 8D 4A FF            lea ecx,[edx-01h]            tan+214     29        
14          0x7c902f17     0x 8B 18               mov ebx,[eax]                tan+217     14        
            0x7c902f19     0x F0 0F C7 4D 00      lock cmpxchg8b [ebp+00h]                           
2842        0x7c902f1e     0x 75 F0               jnz $-0eh (0x7c902f10)       tan+224     2842

struct bad_const_str
{
    const char *ptr;

    const_str()
    {
        ptr = NULL;
    }

    const_str(const char *pa, const char *pb)
    {
        ptr = pa;
    }
};

import std.stdio, std.string, std.perf;

void main()
{
  auto t = new HighPerformanceCounter();
    
  t.start();
  
  uint res = 0;

    for(uint i = 0; i < 1000000; ++i)
    res += split("123 345 asdf 23453 asdfas"," ").length;
                
  t.stop();
    
  writefln("res is ", res ," ", t.milliseconds()," ms elapsed.");
}

using System;
using System.Diagnostics;

class Runner
{
  public static void Main()
  {
    Stopwatch stopwatch = new Stopwatch();
    stopwatch.Start();
    
    int res = 0;
  
    for(uint i = 0; i < 1000000; ++i)
      res += "123 345 asdf 23453 asdfas".Split(' ').Length;
      
    stopwatch.Stop();
          
    Console.WriteLine("res is {0}, {1} elapsed",
                      res, stopwatch.Elapsed);
  }
}

using System.Console;
using System.Diagnostics;

def stopwatch = Stopwatch();
stopwatch.Start();
  
mutable res = 0;

repeat(1000000)
  res += "123 345 asdf 23453 asdfas".Split(' ').Length;
  
stopwatch.Stop();
      
WriteLine($"res is $res, $(stopwatch.Elapsed) elapsed");

import time

start = time.clock()
      
res = 0
for i in xrange(1000000):
    res += len("123 345 asdf 23453 asdfas".split(" "))
    
finish = time.clock()    
    
print 'res is %s, %f sec elapsed' % ( res, finish - start )

import time
import psyco
psyco.full()

start = time.clock()
      
res = 0
for i in xrange(1000000):
    res += len("123 345 asdf 23453 asdfas".split(" "))
    
finish = time.clock()    
    
print 'res is %s, %f sec elapsed' % ( res, finish - start )

#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++)
  {
    // так корректней сравнивать, ведь в др программах мы размер не указывали
    // + по моим тестам почти не повлияло на скорость
    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;
}

from time import clock
import psyco
psyco.full()

def run():
    res = 0
    for i in xrange(1000000):
        res += len("123 345 asdf 23453 asdfas".split(" "))
    return res


start = clock()
res = run()   
finish = clock()    
    
print 'res is %s, %f sec elapsed' % ( res, finish - start )

CC>Бо что то мне кажется что тут надо в "консерватории" что то подправить

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

#include <algorithm>
#include <string>
#include <set>

template< class Finder >
class Finder_Holder
    {
    private :
        Finder finder_;

    public :
        Finder_Holder( Finder finder )
            :    finder_( finder )
            {}

        void
        operator()( char c ) { finder_( c ); }
    };

class Finder
    {
    private :
        std::set< char >    tokens_;

    public :
        Finder( std::string tokens )
            :    tokens_( tokens.begin(), tokens.end() )
            {}

        bool
        operator()( char c )
            {
                return tokens_.end() == tokens_.find( c );
            }
    };

Finder_Holder< Finder >
is_any_of( const std::string & value )
    {
        return Finder_Holder< Finder >( Finder( value ) );
    }

template< class Predicate >
void
do_something( const std::string & s, Predicate pred )
    {
        std::for_each( s.begin(), s.end(), pred );
    }

void
test()
    {
        for( int i = 0; i != 1000000; ++i )
            do_something( "123 345 asdf 23453 asdfas", is_any_of( " " ) );
    }

int
main()
    {
        test();

        return 0;
    }

bash-3.1$ time t1.exe

real    0m5.172s
user    0m0.031s
sys     0m0.000s

#include <algorithm>
#include <string>
#include <set>

template< class Finder >
class Finder_Holder
    {
    private :
        const Finder & finder_;

    public :
        Finder_Holder( const Finder & finder )
            :    finder_( finder )
            {}

        void
        operator()( char c ) const { finder_( c ); }
    };

class Finder
    {
    private :
        std::set< char >    tokens_;

    public :
        Finder( const std::string & tokens )
            :    tokens_( tokens.begin(), tokens.end() )
            {}

        bool
        operator()( char c ) const
            {
                return tokens_.end() == tokens_.find( c );
            }
    };

Finder_Holder< Finder >
is_any_of( const std::string & value )
    {
        return Finder_Holder< Finder >( Finder( value ) );
    }

template< class Predicate >
void
do_something( const std::string & s, const Predicate & pred )
    {
        std::for_each( s.begin(), s.end(), pred );
    }

void
test()
    {
        const Finder_Holder< Finder > pred = is_any_of( " " );
        for( int i = 0; i != 1000000; ++i )
            do_something( "123 345 asdf 23453 asdfas", pred );
    }

int
main()
    {
        test();

        return 0;
    }

bash-3.1$ time t2.exe

real    0m0.406s
user    0m0.015s
sys     0m0.015s

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

using namespace std;
using boost::algorithm::split;

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

int main(int argc, char *argv[])
{
int r = 0;

vector<string> tokens(5);

for(int i = 0; i < 1000000; i++)
{
    split(tokens, "123 345 asdf 23453 asdfas", is_space);
    r += tokens.size();
}

return 0;
}

D>то заместо ~20 сек., получаем ~5 сек., на VC++ 8.0.

#include <iostream>
#include <sstream>
#include <vector>

using namespace std;

int main(int argc, char *argv[])
{
int r = 0;
vector<string> tokens(5);

for(int i = 0; i < 1000000; i++)
{
    istringstream istr("123 345 asdf 23453 asdfas");
    string word;
    int k = 0;
    
    while(!istr.eof())
    {
    istr >> word;
    tokens[k++] = word;
    }
    
    r += k;
}

cout << r << endl;

return 0;
}

АХ>Надо идти к ним на форум ругаться

#include <iostream>
#include <string>
#include <vector>

using namespace std;

void split(vector<string> &out, const char *text, bool (*pred)(char))
{
out.erase(out.begin(), out.end());
const char *begin_word = text;
for(; *text; ++text)
 {
  const char c = *text;
  if(pred(c))
  {
  out.push_back(string(begin_word, text - begin_word));
  begin_word = text + 1;
  }
 }
 
if(text != begin_word)
 out.push_back(string(begin_word, text - begin_word));
}


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

int main(int argc, char *argv[])
{
int r = 0;

vector<string> tokens(5);

for(int i = 0; i < 1000000; i++)
{
    split(tokens, "123 345 asdf 23453 asdfas", is_space);
    r += tokens.size();
}

cout << r << endl;

/*for(int i = 0; i < tokens.size(); ++i)
 {
 cout << tokens[i] << endl;
 }*/

return 0;
}

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

#!/bin/sh
# restart using tclsh \
exec tclsh "$0" "$@"

set _len 0
set x [time {
    for {set x 0} {$x<1000000} {incr x} {
        incr _len [llength [split "123 345 asdf 23453 asdfas"]]
    }
}]
puts $x
puts $_len
puts "done"

C>Поигравши с лисповыми макрами, мой друг улучьшил время выполнения кода до 0 мс, притом время выполнения совершенно не зависит от N. ))

print 50000

void MyF1(vector<int>& vec, int s)
{
    transform(vec.begin(), vec.end(), vec.begin(), (s + _1));
}

?MyF1@@YAXAAV?$vector@HV?$allocator@H@std@@@std@@H@Z PROC ; MyF1, COMDAT
    mov    eax, DWORD PTR _vec$[esp-4]
    mov    ecx, DWORD PTR [eax+4]
    mov    edx, DWORD PTR [eax+8]
    mov    eax, ecx
    cmp    eax, edx
    push    esi
    push    edi
    je    SHORT $LN71@MyF1
    mov    esi, DWORD PTR _s$[esp+4]
$LL82@MyF1:
    mov    edi, DWORD PTR [eax]
    add    edi, esi
    mov    DWORD PTR [ecx], edi
    add    eax, 4
    add    ecx, 4
    cmp    eax, edx
    jne    SHORT $LL82@MyF1
$LN71@MyF1:
    pop    edi
    pop    esi
    ret    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;
  long ts = sysconf(_SC_CLK_TCK);
  double start = ((double) times(&t) / ts) * 1000;
#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
  double stop = ((double) times(&t) / ts) * 1000;
#endif

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

/*!
    \since v.4.2.7
    \brief Предикат для std::find_if.

    Для очередного состояния проверяет возможность слияния
    с состоянием из другого класса агентов.

    Определяет, есть ли среди всех классов, на которые ссылаются
    состояния, еще не полностью определенные классы.
*/
class    merge_possibility_checker_t
    :    public std::unary_function<
            const state_handler_impl_ptr_vector_t::value_type &,
            bool >
    {
    private :
        /*! Список всех классов. */
        const class_map_t & m_all_classes;

        /*! Список состояний всех классов */
        const std_class_relation_handler_t::class_info_map_t &
            m_classes_state;

        /*! Принимает значение true, если были найдены не
            полностью определенные классы. */
        bool    & m_is_incomplete_class_found;

        /*! Приемник описания ошибки. */
        std::string &    m_error_desc;

    public :
        //! Основной конструктор.
        merge_possibility_checker_t(
            //! Список всех классов.
            const class_map_t & all_classes,
            const std_class_relation_handler_t::class_info_map_t &
                classes_state,
            bool & is_incomplete_class_found,
            //! Приемник описания ошибки.
            std::string & error_desc )
            :    m_is_incomplete_class_found( is_incomplete_class_found )
            ,    m_all_classes( all_classes )
            ,    m_classes_state( classes_state )
            ,    m_error_desc( error_desc )
            {}

        result_type
        operator()( argument_type a );

    private :
        /*! Проверка наличия указанного состояния в указанном
            классе.

            \return true, если состояние найдено. */
        bool
        try_find_state_in_class(
            //! Имя искомого состояния.
            const std::string & state_name,
            //! Класс, в котором состояние нужно найти.
            const class_handler_impl_t & class_handler );
    };

merge_possibility_checker_t::result_type
merge_possibility_checker_t::operator()( argument_type a )
    {
        bool result = false;

        const state_handler_impl_t::merge_list_t & merge_list =
            a->merge_list();

        for( state_handler_impl_t::merge_list_t::const_iterator
                it = merge_list.begin(), it_end = merge_list.end();
            it != it_end;
            ++it )
            {
                bool is_merge_valid = false;

                const state_handler_impl_t::merge_t & m = *it;

                // Должен быть известен класс.
                class_map_t::const_iterator it_class = m_all_classes.find(
                    m.m_class_name );
                if( it_class != m_all_classes.end() )
                    {
                        int state = m_classes_state.find(
                            m.m_class_name )->second.m_state;
                        // Класс должен быть полностью определен.
                        if( std_class_relation_handler_t::state_valid == state )
                            {
                                // Должно быть известно состояние.
                                if( try_find_state_in_class(
                                    m.m_state_name, *( it_class->second ) ) )
                                    // Все хорошо. Поэтому, чтобы перейти к обработке
                                    // следующего состояния, нужно возвратить false.
                                    is_merge_valid = true;
                                else
                                    {
                                        // Состояние не известно.
                                        m_error_desc += std::string( "state '" ) +
                                            a->query_name() +
                                            "' requires merging with undefined state '" +
                                            m.m_state_name + "' from class '" +
                                            m.m_class_name + "';";
                                    }
                            }
                        else if( std_class_relation_handler_t::state_invalid == state )
                            // Нашли ссылку на некорректный класс.
                            m_error_desc += std::string( "state '" ) +
                                a->query_name() +
                                "' requires merging with invalid class '" +
                                m.m_class_name + "';";
                        else
                            {
                                // Класс еще не определен.
                                m_is_incomplete_class_found = true;
                                m_error_desc += std::string( "incomplete class: " ) +
                                    m.m_class_name + ";";
                            }
                    }
                else
                    // Нашли ссылку на неизвестный класс.
                    m_error_desc += std::string( "state '" ) + a->query_name() +
                        "' requires merging with undefined class '" +
                        m.m_class_name + "';";

                // Если текущее слияние не корректно, то и состояние не может
                // быть корректным.
                if( !is_merge_valid )
                    result = true;
            }

        return result;
    }

bool
merge_possibility_checker_t::try_find_state_in_class(
    const std::string & state_name,
    const class_handler_impl_t & class_handler )
    {
        const state_handler_impl_ptr_vector_t & states =
            class_handler.query_state_handlers();
        return ( states.end() != std::find_if(
            states.begin(), states.end(),
            state_by_name_finder_t( state_name ) ) );
    }

int
std_class_relation_handler_t::try_merge_states(
    const class_handler_impl_t & class_handler,
    const class_map_t & all_classes,
    std::string & error_desc )
    {
        // Берем все состояния, которые нуждаются в слиянии.
        state_handler_impl_ptr_vector_t states_for_merging =
            class_handler.states_for_merge();

        // Проверяем возможность проведения слияния.
        bool is_incomplete_class_found = false;
        merge_possibility_checker_t checker( all_classes, m_classes,
            is_incomplete_class_found, error_desc );
        if( states_for_merging.end() != std::find_if(
            states_for_merging.begin(), states_for_merging.end(),
            checker ) )
            // Слияние не возможно. Осталось только определить,
            // по какой причине.
            return ( is_incomplete_class_found ?
                state_not_processed :
                state_invalid );

        // Выполняем слияние.
        std::for_each( states_for_merging.begin(),
            states_for_merging.end(),
            merge_maker_t( all_classes ) );

        return state_valid;
    }

D>void MyF1(vector<int>& vec, int s)
D>{
D>    transform(vec.begin(), vec.end(), vec.begin(), (s + _1));
D>}
D>

transform.(s + _);