726 lines
17 KiB
C++
726 lines
17 KiB
C++
|
|
#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;
|
|
}
|