initial check in
This commit is contained in:
725
std_vs_qt.cpp
Normal file
725
std_vs_qt.cpp
Normal file
@@ -0,0 +1,725 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include "getCurrentTime.h"
|
||||
|
||||
#include <QtCore/QCoreApplication>
|
||||
#include <QtCore/QString>
|
||||
#include <list>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
#if defined( _MSC_VER )
|
||||
#pragma intrinsic (memcpy,memcmp,memset,strcat,strcmp,strcpy,strlen)
|
||||
#endif
|
||||
|
||||
namespace constructor
|
||||
{
|
||||
void * operator new( size_t count,
|
||||
void * object )
|
||||
{
|
||||
return object;
|
||||
}
|
||||
}
|
||||
|
||||
//#define ALLOC_AT_ONCE
|
||||
//#define USE_MALLOC
|
||||
// TEMPLATE CLASS allocator
|
||||
template<class T, int N>
|
||||
class fast_allocator
|
||||
#ifndef USE_MALLOC
|
||||
: public std::allocator<T>
|
||||
#endif
|
||||
{
|
||||
char memory[N];
|
||||
#ifndef ALLOC_AT_ONCE
|
||||
char* marker;
|
||||
#endif
|
||||
|
||||
public:
|
||||
typedef std::allocator<T> MyBase;
|
||||
typedef T value_type;
|
||||
typedef value_type *pointer;
|
||||
typedef value_type & reference;
|
||||
typedef const value_type *const_pointer;
|
||||
typedef const value_type & const_reference;
|
||||
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
|
||||
template<class _Other>
|
||||
struct rebind
|
||||
{ // convert an allocator<_Ty> to an allocator <_Other>
|
||||
typedef fast_allocator<_Other,N> other;
|
||||
};
|
||||
|
||||
// return address of mutable _Val
|
||||
pointer address(reference _Val) const
|
||||
{
|
||||
return (&_Val);
|
||||
}
|
||||
|
||||
const_pointer address(const_reference _Val) const
|
||||
{ // return address of nonmutable _Val
|
||||
return (&_Val);
|
||||
}
|
||||
|
||||
fast_allocator() throw()
|
||||
#ifndef ALLOC_AT_ONCE
|
||||
: marker( memory )
|
||||
#endif
|
||||
{}
|
||||
|
||||
// construct by copying (do nothing)
|
||||
fast_allocator( const fast_allocator<T,N>& ) throw()
|
||||
#ifndef ALLOC_AT_ONCE
|
||||
: marker( memory )
|
||||
#endif
|
||||
{}
|
||||
|
||||
// construct from a related allocator (do nothing)
|
||||
// template<class _Other>
|
||||
// allocatorN(const std::allocator<_Other>&) throw()
|
||||
// : marker( memory )
|
||||
// {}
|
||||
|
||||
// deallocate object at _Ptr, ignore size
|
||||
void deallocate(pointer p, size_type n )
|
||||
{
|
||||
#ifdef ALLOC_AT_ONCE
|
||||
if ( p != static_cast<pointer>(memory) )
|
||||
#ifdef USE_MALLOC
|
||||
free( p );
|
||||
#else
|
||||
return MyBase::deallocate( p, n );
|
||||
#endif
|
||||
#else/*ALLOC_AT_ONCE*/
|
||||
if ( p+n == marker )
|
||||
marker = p;
|
||||
else if ( p < static_cast<pointer>(memory)
|
||||
|| static_cast<pointer>(&memory[N]) <= p )
|
||||
#ifdef USE_MALLOC
|
||||
free( p );
|
||||
#else
|
||||
return MyBase::deallocate( p, n );
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
// allocate array of n elements
|
||||
pointer allocate(size_type nCount)
|
||||
{
|
||||
register size_type s = sizeof(T)*nCount;
|
||||
#ifdef ALLOC_AT_ONCE
|
||||
if ( sizeof(T)*nCount < N )
|
||||
return static_cast<pointer>(memory);
|
||||
#else
|
||||
if ( sizeof(T)*nCount < (&memory[N] - marker) )
|
||||
{
|
||||
pointer p = static_cast<pointer>(marker);
|
||||
marker += s;
|
||||
return p;
|
||||
}
|
||||
#endif
|
||||
else
|
||||
#ifdef USE_MALLOC
|
||||
return static_cast<char*>(malloc( s ));
|
||||
#else
|
||||
return MyBase::allocate( nCount );
|
||||
#endif
|
||||
}
|
||||
|
||||
// allocate array of n elements, ignore hint
|
||||
pointer allocate(size_type nCount, const void *)
|
||||
{
|
||||
return allocate(nCount);
|
||||
}
|
||||
|
||||
// construct object at _Ptr with value _Val
|
||||
void construct(pointer _Ptr, const T& _Val)
|
||||
{
|
||||
::new (_Ptr) T(_Val);
|
||||
}
|
||||
|
||||
// destroy object at _Ptr
|
||||
void destroy( pointer p )
|
||||
{
|
||||
p->~T();
|
||||
}
|
||||
|
||||
// estimate maximum array size
|
||||
size_type max_size() const throw()
|
||||
{
|
||||
#ifdef USE_MALLOC
|
||||
return (size_type)(-1) / sizeof(T);
|
||||
#else
|
||||
// return MyBase::max_size();
|
||||
return (int)(-1) / sizeof(T);
|
||||
#endif
|
||||
}
|
||||
|
||||
// bool operator( const fast_allocator& op )
|
||||
// {
|
||||
// return &op == this;
|
||||
// }
|
||||
};
|
||||
|
||||
template <class T, int N>
|
||||
inline
|
||||
bool operator== ( const fast_allocator<T,N>& op1,
|
||||
const fast_allocator<T,N>& op2 )
|
||||
{
|
||||
return &op1 == &op2;
|
||||
}
|
||||
|
||||
// STRUCT char_traits<char> (FROM <string>)
|
||||
template<class C>
|
||||
struct fast_char_traits
|
||||
{ // properties of a string or stream char element
|
||||
typedef C char_type;
|
||||
typedef int int_type;
|
||||
typedef std::streampos pos_type;
|
||||
typedef std::streamoff off_type;
|
||||
// typedef _Mbstatet state_type;
|
||||
|
||||
// assign an element
|
||||
static void assign( char_type& l, const char_type& r)
|
||||
{
|
||||
l = r;
|
||||
}
|
||||
|
||||
// test for element equality
|
||||
static bool eq( const char_type& l, const char_type& r)
|
||||
{
|
||||
return (l == r);
|
||||
}
|
||||
|
||||
// test if l precedes r
|
||||
static bool lt( const char_type& l, const char_type& r)
|
||||
{
|
||||
return (l < r);
|
||||
}
|
||||
|
||||
// compare [_First1, _First1 + n) with [_First2, ...)
|
||||
static int compare(const char_type *op1, const char_type *op2, size_t n)
|
||||
{
|
||||
return (::memcmp(op1, op2, n*sizeof(char_type)));
|
||||
}
|
||||
|
||||
// find length of null-terminated string
|
||||
static size_t length(const char_type * op)
|
||||
{
|
||||
return (::strlen(op));
|
||||
}
|
||||
|
||||
// assume there is enough space in the destination buffer
|
||||
static char_type * copy(char_type *dest, const char_type *src, size_t n)
|
||||
{
|
||||
return reinterpret_cast<char_type*>(::memcpy( dest, src, n*sizeof(char_type) ));
|
||||
}
|
||||
|
||||
// look for _Ch in [_First, _First + n)
|
||||
static const char_type * find(const char_type * src, size_t n, const char_type& ch)
|
||||
{
|
||||
return ((const char_type *)::memchr(src, ch, n));
|
||||
}
|
||||
|
||||
// move [_First1, _First1 + n) to [_First2, ...)
|
||||
// assume there is enough space in the destination buffer
|
||||
static char_type * move(char_type *dest, const char_type *src, size_t n)
|
||||
{
|
||||
return reinterpret_cast<char_type*>(::memmove(dest, src, n*sizeof(char_type)));
|
||||
}
|
||||
|
||||
// assign n * _Ch to [_First, ...)
|
||||
static char_type * assign(char_type *_First, size_t n, char_type _Ch)
|
||||
{
|
||||
return ((char_type *)::memset(_First, _Ch, n));
|
||||
}
|
||||
|
||||
// convert metacharacter to character
|
||||
static char_type to_char_type(const int_type& chMeta)
|
||||
{
|
||||
return ((char_type)chMeta);
|
||||
}
|
||||
|
||||
// convert character to metacharacter
|
||||
static int_type to_int_type(const char_type& ch)
|
||||
{
|
||||
return ((unsigned char)ch);
|
||||
}
|
||||
|
||||
// test for metacharacter equality
|
||||
static bool eq_int_type(const int_type& l, const int_type& r)
|
||||
{
|
||||
return (l == r);
|
||||
}
|
||||
|
||||
// return end-of-file metacharacter
|
||||
static int_type eof()
|
||||
{
|
||||
return (EOF);
|
||||
}
|
||||
|
||||
// return anything but EOF
|
||||
static int_type not_eof(const int_type& chMeta)
|
||||
{
|
||||
return (chMeta != eof() ? chMeta : !eof());
|
||||
}
|
||||
};
|
||||
|
||||
template <
|
||||
class CharType,
|
||||
class Traits=fast_char_traits<CharType>,
|
||||
class Allocator=fast_allocator<CharType,64>
|
||||
>
|
||||
class fast_basic_string : public std::basic_string< CharType, Traits, Allocator >
|
||||
{
|
||||
public:
|
||||
typedef fast_basic_string< CharType, Traits, Allocator > MySelf;
|
||||
typedef std::basic_string< CharType, Traits, Allocator > MyBase;
|
||||
|
||||
fast_basic_string(
|
||||
const typename MyBase::value_type* _Ptr,
|
||||
typename MyBase::size_type _Count,
|
||||
const typename MyBase::allocator_type& _Al = Allocator ( )
|
||||
)
|
||||
: std::basic_string< CharType, Traits, Allocator >( _Ptr, _Count, _Al )
|
||||
{}
|
||||
|
||||
fast_basic_string(
|
||||
const typename MyBase::value_type* _Ptr,
|
||||
const typename MyBase::allocator_type& _Al = Allocator ( )
|
||||
)
|
||||
: std::basic_string< CharType, Traits, Allocator >( _Ptr, _Al )
|
||||
{}
|
||||
|
||||
fast_basic_string(
|
||||
const MyBase& _Right,
|
||||
typename MyBase::size_type _Roff = 0,
|
||||
typename MyBase::size_type _Count = npos,
|
||||
const typename MyBase::allocator_type& _Al = Allocator ( )
|
||||
)
|
||||
: std::basic_string< CharType, Traits, Allocator >( _Right, _Roff, _Count, _Al )
|
||||
{}
|
||||
|
||||
fast_basic_string(
|
||||
typename MyBase::size_type _Count,
|
||||
typename MyBase::value_type _Ch,
|
||||
const typename MyBase::allocator_type& _Al = Allocator ( )
|
||||
)
|
||||
: std::basic_string< CharType, Traits, Allocator >( _Count, _Ch, _Al )
|
||||
{}
|
||||
|
||||
explicit fast_basic_string(
|
||||
const typename MyBase::allocator_type& _Al = Allocator ( )
|
||||
)
|
||||
: std::basic_string< CharType, Traits, Allocator >( _Al )
|
||||
{}
|
||||
|
||||
#if 0 //ndef _MSC_VER
|
||||
bool operator == ( const MySelf& str )
|
||||
{
|
||||
return ( str.size() != size() ) ? false : MyBase::operator == ( str );
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
#if 1 //def _MSC_VER
|
||||
template <class Elem, class Traits, class Alloc>
|
||||
inline
|
||||
bool operator==(
|
||||
const fast_basic_string<Elem, Traits, Alloc>& l,
|
||||
const fast_basic_string<Elem, Traits, Alloc>& r )
|
||||
{ // test for string equality
|
||||
return (l.size() != r.size()) ?
|
||||
false : (l.compare(r) == 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
typedef fast_basic_string< char > fast_string;
|
||||
|
||||
|
||||
const char* testStr[] =
|
||||
{
|
||||
"1", //1
|
||||
"12", //2
|
||||
"123", //3
|
||||
"1234", //4
|
||||
"12345", //5
|
||||
"123456", //6
|
||||
"1234567", //7
|
||||
"12345678", //8
|
||||
"123456781", //9
|
||||
"1234567812", //10
|
||||
"12345678123", //11
|
||||
"123456781234", //12
|
||||
"1234567812345", //13
|
||||
"12345678123456", //14
|
||||
"123456781234567", //15
|
||||
"1234567812345678", //16
|
||||
"12345678123456781", //17
|
||||
"123456781234567812", //18
|
||||
"1234567812345678123", //19
|
||||
"12345678123456781234567812345678", //32
|
||||
"12345678123456781234567812345678123456781234567812345678123456", //62
|
||||
"123456781234567812345678123456781234567812345678123456781234567", //63
|
||||
"1234567812345678123456781234567812345678123456781234567812345678", //64
|
||||
|
||||
"12345678123456781234567812345678123456781234567812345678123456781",
|
||||
"123456781234567812345678123456781234567812345678123456781234567812",
|
||||
"1234567812345678123456781234567812345678123456781234567812345678123",
|
||||
"12345678123456781234567812345678123456781234567812345678123456781234",
|
||||
"123456781234567812345678123456781234567812345678123456781234567812345678",
|
||||
"12345678123456781234567812345678123456781234567812345678123456781234567812345678",
|
||||
"123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678",
|
||||
"12345678123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678",
|
||||
"12345678123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678"
|
||||
"12345678123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678",
|
||||
|
||||
};
|
||||
|
||||
template <class S, class S2>
|
||||
inline
|
||||
int initString( const S2& str )
|
||||
{
|
||||
S a( str );
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <class S, class S2>
|
||||
inline
|
||||
int assignString( const S2& str )
|
||||
{
|
||||
S a;
|
||||
a = str;
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <class S>
|
||||
inline
|
||||
int cmpEqString( const S& str1, const S& str2 )
|
||||
{
|
||||
return str1 == str2;
|
||||
}
|
||||
|
||||
template <class S>
|
||||
inline
|
||||
int cmpLessString( const S& str1, const S& str2 )
|
||||
{
|
||||
return str1 < str2;
|
||||
}
|
||||
|
||||
/*
|
||||
std::list<QString*> listQString;
|
||||
int alocQString(char const * const pStr)
|
||||
{
|
||||
QString* a = new QString(pStr);
|
||||
listQString.push_back( a );
|
||||
return 0;
|
||||
}
|
||||
|
||||
int freeQString()
|
||||
{
|
||||
std::list<QString*>::iterator it = listQString.begin();
|
||||
std::list<QString*>::iterator itEnd = listQString.end();
|
||||
for ( ; it!=itEnd; ++it )
|
||||
delete *it;
|
||||
listQString.clear();
|
||||
return 0;
|
||||
}
|
||||
|
||||
std::list<std::string*> listStdString;
|
||||
int alocStdString(char const * const pStr)
|
||||
{
|
||||
std::string* a = new std::string(pStr);
|
||||
listStdString.push_back( a );
|
||||
return 0;
|
||||
}
|
||||
|
||||
int freeStdString()
|
||||
{
|
||||
std::list<std::string*>::iterator it = listStdString.begin();
|
||||
std::list<std::string*>::iterator itEnd = listStdString.end();
|
||||
for ( ; it!=itEnd; ++it )
|
||||
delete *it;
|
||||
listStdString.clear();
|
||||
return 0;
|
||||
}
|
||||
*/
|
||||
|
||||
template< class S1,
|
||||
class S2,
|
||||
int (*func1)( const S1& ),
|
||||
int (*func2)( const S2& ),
|
||||
int nProbes >
|
||||
void testStringsUnary( char const * const pStr )
|
||||
{
|
||||
double dwStart, dwEnd;
|
||||
|
||||
S1 s1_op( pStr );
|
||||
S2 s2_op( pStr );
|
||||
|
||||
dwStart = getCurrentTime();
|
||||
for ( int i = nProbes; i; --i )
|
||||
volatile int a = func1(s1_op);
|
||||
dwEnd = getCurrentTime();
|
||||
double dblDiff1 = dwEnd - dwStart;
|
||||
|
||||
dwStart = getCurrentTime();
|
||||
for ( int i = nProbes; i; --i )
|
||||
volatile int a = func2(s2_op);
|
||||
dwEnd = getCurrentTime();
|
||||
double dblDiff2 = dwEnd - dwStart;
|
||||
|
||||
printf( "m1 %f m2 %f m1/m2 %f probs=%d\n", dblDiff1, dblDiff2, dblDiff1/dblDiff2, nProbes );
|
||||
}
|
||||
|
||||
template< class S1,
|
||||
class S2,
|
||||
int (*func1)(const S1&, const S1& ),
|
||||
int (*func2)(const S2&, const S2& ),
|
||||
int nProbes >
|
||||
void testStringsBinary( char const * const pStr1, char const * const pStr2 )
|
||||
{
|
||||
double dwStart, dwEnd;
|
||||
|
||||
S1 s1_op1( pStr1 );
|
||||
S1 s1_op2( pStr2 );
|
||||
|
||||
S2 s2_op1( pStr1 );
|
||||
S2 s2_op2( pStr2 );
|
||||
|
||||
dwStart = getCurrentTime();
|
||||
for ( int i = nProbes; i; --i )
|
||||
volatile int a = func1(s1_op1,s1_op2);
|
||||
dwEnd = getCurrentTime();
|
||||
double dblDiff1 = dwEnd - dwStart;
|
||||
|
||||
dwStart = getCurrentTime();
|
||||
for ( int i = nProbes; i; --i )
|
||||
volatile int a = func2(s2_op1,s2_op2);
|
||||
dwEnd = getCurrentTime();
|
||||
double dblDiff2 = dwEnd - dwStart;
|
||||
|
||||
printf( "m1 %f m2 %f m1/m2 %f probs=%d\n", dblDiff1, dblDiff2, dblDiff1/dblDiff2, nProbes );
|
||||
}
|
||||
|
||||
/*
|
||||
void testStrings( char const * const pStr )
|
||||
{
|
||||
double dwStart, dwEnd;
|
||||
|
||||
int nProbes = 5000000;
|
||||
|
||||
dwStart = getCurrentTime();
|
||||
for ( int i = nProbes; i; --i )
|
||||
volatile int a = alocStdString(pStr);
|
||||
dwEnd = getCurrentTime();
|
||||
printf( "alocStdString \t%f\t\t", dwEnd - dwStart );
|
||||
dwStart = getCurrentTime();
|
||||
{
|
||||
volatile int a = freeStdString();
|
||||
}
|
||||
dwEnd = getCurrentTime();
|
||||
printf( "freeStdString \t%f\n", dwEnd - dwStart );
|
||||
|
||||
|
||||
dwStart = getCurrentTime();
|
||||
for ( int i = nProbes; i; --i )
|
||||
volatile int a = alocQString(pStr);
|
||||
dwEnd = getCurrentTime();
|
||||
printf( "alocQString \t%f\t\t", dwEnd - dwStart );
|
||||
dwStart = getCurrentTime();
|
||||
{
|
||||
volatile int a = freeQString();
|
||||
}
|
||||
dwEnd = getCurrentTime();
|
||||
printf( "freeQString \t%f\n", dwEnd - dwStart );
|
||||
|
||||
dwStart = getCurrentTime();
|
||||
for ( int i = nProbes; i; --i )
|
||||
volatile int a = alocStdString(pStr);
|
||||
dwEnd = getCurrentTime();
|
||||
printf( "alocStdString \t%f\t\t", dwEnd - dwStart );
|
||||
dwStart = getCurrentTime();
|
||||
{
|
||||
volatile int a = freeStdString();
|
||||
}
|
||||
dwEnd = getCurrentTime();
|
||||
printf( "freeStdString \t%f\n", dwEnd - dwStart );
|
||||
|
||||
|
||||
dwStart = getCurrentTime();
|
||||
for ( int i = nProbes; i; --i )
|
||||
volatile int a = alocQString(pStr);
|
||||
dwEnd = getCurrentTime();
|
||||
printf( "alocQString \t%f\t\t", dwEnd - dwStart );
|
||||
dwStart = getCurrentTime();
|
||||
{
|
||||
volatile int a = freeQString();
|
||||
}
|
||||
dwEnd = getCurrentTime();
|
||||
printf( "freeQString \t%f\n", dwEnd - dwStart );
|
||||
}
|
||||
*/
|
||||
|
||||
template <class S1, class S2>
|
||||
void test()
|
||||
{
|
||||
#if 1
|
||||
/*
|
||||
*/
|
||||
puts( "constructor(char*) \n"
|
||||
"============================================================");
|
||||
for ( int i = 0; i < sizeof(testStr)/sizeof(testStr[0]); ++i )
|
||||
{
|
||||
printf("strlen: %3d ", strlen(testStr[i]), testStr[i] );
|
||||
testStringsUnary<char const * const,
|
||||
char const * const,
|
||||
initString<S1, char const * const>,
|
||||
initString<S2, char const * const>,
|
||||
1000000>( testStr[i] );
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 1
|
||||
/*
|
||||
*/
|
||||
puts( "constructor(native) \n"
|
||||
"============================================================");
|
||||
for ( int i = 0; i < sizeof(testStr)/sizeof(testStr[0]); ++i )
|
||||
{
|
||||
printf("strlen: %3d ", strlen(testStr[i]), testStr[i] );
|
||||
testStringsUnary<S1,
|
||||
S2,
|
||||
initString<S1, S1>,
|
||||
initString<S2, S2>,
|
||||
1000000>( testStr[i] );
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 1
|
||||
/*
|
||||
*/
|
||||
puts( "operator = (char*) \n"
|
||||
"============================================================");
|
||||
for ( int i = 0; i < sizeof(testStr)/sizeof(testStr[0]); ++i )
|
||||
{
|
||||
printf("strlen: %3d ", strlen(testStr[i]), testStr[i] );
|
||||
testStringsUnary<char const * const,
|
||||
char const * const,
|
||||
assignString<S1, char const * const>,
|
||||
assignString<S2, char const * const>,
|
||||
1000000>( testStr[i] );
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 1
|
||||
/*
|
||||
*/
|
||||
puts( "operator = (native) \n"
|
||||
"============================================================");
|
||||
for ( int i = 0; i < sizeof(testStr)/sizeof(testStr[0]); ++i )
|
||||
{
|
||||
printf("strlen: %3d ", strlen(testStr[i]), testStr[i] );
|
||||
testStringsUnary<S1,
|
||||
S2,
|
||||
assignString<S1, S1>,
|
||||
assignString<S2, S2>,
|
||||
1000000>( testStr[i] );
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 1
|
||||
/*
|
||||
*/
|
||||
puts( "operator == () (equal strings)\n"
|
||||
"============================================================");
|
||||
for ( int i = 0; i < sizeof(testStr)/sizeof(testStr[0]) -1; ++i )
|
||||
{
|
||||
printf("strlen: %3d ", strlen(testStr[i]), testStr[i] );
|
||||
testStringsBinary< S1,
|
||||
S2,
|
||||
cmpEqString<S1>,
|
||||
cmpEqString<S2>,
|
||||
1000000>( testStr[i], testStr[i] );
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 1
|
||||
/*
|
||||
*/
|
||||
puts( "operator == () (never equal strings)\n"
|
||||
"============================================================");
|
||||
for ( int i = 0; i < sizeof(testStr)/sizeof(testStr[0]) -1; ++i )
|
||||
{
|
||||
printf("strlen: %3d ", strlen(testStr[i]), testStr[i] );
|
||||
testStringsBinary< S1,
|
||||
S2,
|
||||
cmpEqString<S1>,
|
||||
cmpEqString<S2>,
|
||||
1000000>( testStr[i], testStr[i+1] );
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 1
|
||||
/*
|
||||
*/
|
||||
puts( "operator < (less strings)\n"
|
||||
"============================================================");
|
||||
for ( int i = 0; i < sizeof(testStr)/sizeof(testStr[0]) -1; ++i )
|
||||
{
|
||||
printf("strlen: %3d ", strlen(testStr[i]), testStr[i] );
|
||||
testStringsBinary< S1,
|
||||
S2,
|
||||
cmpLessString<S1>,
|
||||
cmpLessString<S2>,
|
||||
1000000>( testStr[i], testStr[i+1] );
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 1
|
||||
/*
|
||||
*/
|
||||
puts( "operator < () (great strings)\n"
|
||||
"============================================================");
|
||||
for ( int i = 0; i < sizeof(testStr)/sizeof(testStr[0]) -1; ++i )
|
||||
{
|
||||
printf("strlen: %3d ", strlen(testStr[i]), testStr[i] );
|
||||
testStringsBinary< S1,
|
||||
S2,
|
||||
cmpLessString<S1>,
|
||||
cmpLessString<S2>,
|
||||
1000000>( testStr[i+1], testStr[i] );
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
// Init
|
||||
initGetCurrentTimeLib();
|
||||
double dwStart, dwEnd;
|
||||
int nProbes;
|
||||
|
||||
QCoreApplication a(argc, argv);
|
||||
|
||||
#if 1
|
||||
puts( "************************************************************\n"
|
||||
"************************************************************\n"
|
||||
"Testing m1=QString vs m2=std::string \n"
|
||||
"************************************************************");
|
||||
test<QString,std::string>();
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
puts( "************************************************************\n"
|
||||
"************************************************************\n"
|
||||
"Testing m1=QString vs m2=fast_string \n"
|
||||
"************************************************************");
|
||||
test<QString,fast_string>();
|
||||
#endif
|
||||
|
||||
// return a.exec();
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user