3. anfängerprobleme mit sprintf

anfängerprobleme mit sprintf

  • E

    [quote="Michael E."]

    Ethon schrieb:

    Swordfish schrieb:

    Ethon schrieb:

    return std::basic_string<CharT>(&(*iter), buffer.end());

    Bist Du sicher, daß basic_string diesen c-tor haben muss?

    Jeder Container lässt sich garantiert mit einem Inputiteratorenpaar konstruieren, bin mir zu 100% sicher dass es auch für std::basic_string vorgeschrieben ist, man findet ihn auch in jeder C++ Referenz.

    Nur ist das da kein Inputiteratorenpaar.

    Ein Zeiger unterstützt alle Operationen, die ein Inputiterator können muss, ist von daher also kompatibel.

    Swordfish: 594.549
Hacker:    1022.05
Ethon:     176.339
Ethon 2:   34.5288
Ethon 3:   49.962
Incocnito: 71.5127

    Interessant dass bei dir die dritte Version langsamer ist, beim GCC war sie schneller.

    Er meint sicher

    return std::basic_string<CharT>(iter.base(), buffer.end());

    Was es nicht alles gibt, danke.

    0
  • M

    Ethon schrieb:

    Ein Zeiger unterstützt alle Operationen, die ein Inputiterator können muss, ist von daher also kompatibel.

    template<class InputIterator>
basic_string(InputIterator begin, InputIterator end,
const Allocator& a = Allocator());

    Also müssen die beiden Parameter denselben Typ haben. Da Paragraph 21.4.5 sagt, dass string::iterator implementation defined ist mit Bezug auf Paragraph 23.2, darfst du dann die Stelle suchen, an der steht, dass string::iterator einen nicht expliziten einstelligen Konstruktor mit einem Pointer als Parameter hat (keine Ahnung, obs die Garantie gibt, bin aber zu faul zum Suchen).

    0
  • I

    Lustig. Wenn ich diesen Code hier kompiliere, erhalte ich folgende Ergebnisse unterm GCC (-O3):

    Swordfish: 418.613
    Hacker: 1298.35
    Ethon: 2315.44
    Inco: 287.326

    Und wenn ich das ganze mit VS-2010 Express mache, hing mein Computer erstmal ne ganze Weile komplett, und dann hatte ich diese Ausgabe:

    Swordfish: 18503.3
    Hacker: 36503.5
    Ethon: 5813.38
    Inco: 12065.5

    Kann mir das jemand erklären 😕

    0
  • E

    Also müssen die beiden Parameter denselben Typ haben.

    Haben sie ja, 2x char*.

    Da Paragraph 21.4.5 sagt, dass string::iterator implementation defined ist mit Bezug auf Paragraph 23.2, darfst du dann die Stelle suchen, an der steht, dass string::iterator einen nicht expliziten einstelligen Konstruktor mit einem Pointer als Parameter hat (keine Ahnung, obs die Garantie gibt, bin aber zu faul zum Suchen).

    Wieso string::iterator? Der Konstruktor ist nicht umsonst templated, damit man jeden anderen Iterator übergeben kann, der dereferenziert einen passenden Char-Typ zurückgibt. Ein String-Iterator wird hier nie konstruiert.
    Dank iterator_traits etc sind du unterschiede zwischen "richtigen" Iteratoren und Pointern nicht existent.

    0

  • Incocnito schrieb:

    Und wenn ich das ganze mit VS-2010 Express mache, hing mein Computer erstmal ne ganze Weile komplett, und dann hatte ich diese Ausgabe: [...]

    Release kompilieren, von hand starten.

    0
  • M

    Sorry, buffer ist ja ein std::array und kein std::string. Die Argumentation bleibt aber dieselbe: buffer.end() ist ein array::iterator, &(*iter) ein Pointer, beide müssen denselben Typ haben.

    0
  • E

    Michael E. schrieb:

    Sorry, buffer ist ja ein std::array und kein std::string. Die Argumentation bleibt aber dieselbe: buffer.end() ist ein array::iterator, &(*iter) ein Pointer, beide müssen denselben Typ haben.

    boost::array implementiert den Iterator als Pointer, da dachte ich mal die std Implementierung macht das genauso. Was sagt der Standard dazu? Implementation defined?

    Im Zweifelsfall muss man es halt korrekt machen, mit der Lösung von Camper, also Base() auf den Reverse Iterator aufrufen.

    0
  • C
    Mod

    Habe zum Spaß auch eine Version geschrieben

    #include <iostream>
#include <algorithm>
#include <array>
#include <limits>
#include <sstream>
#include <iomanip>
#include <string>
#include <cstdlib>
#include <ctime>

std::string to_hex_string_swordfish( unsigned value ) {
    static std::ostringstream ss;
    ss.clear( );
    ss.str( "" );
    ss << std::hex << value;
    return ss.str( );
}

std::string to_hex_string_hacker( unsigned value)
{
    std::ostringstream stream;
    stream << std::hex << value;
    return stream.str();
}

std::string to_hex_string_ethon(unsigned value)
{
    char buffer[sizeof(value) * 2 + 1];
    sprintf(buffer,"%x", value);
    return std::string(buffer);
}

std::string to_hex_string_ethon2(unsigned value)
{
    typedef std::string string_type;
    typedef char CharT;
    string_type result(sizeof(value) * 2, 0);
    typename string_type::reverse_iterator iter = result.rbegin();
    while(value > 16)
    {
        unsigned cur = value % 16;
        *iter = cur < 10 ? CharT('0') + cur : CharT('A') + cur - 10;
        ++iter;
        value /= 16;
    }

    *iter = value < 10 ? CharT('0') + value : CharT('A') + value - 10;
    return result;
}

std::string to_hex_string_ethon3(unsigned value)
{
    typedef char CharT;
    const unsigned Base = 16;
    CharT const lookup[] =
        {   CharT('0'), CharT('1'), CharT('2'), CharT('3'), CharT('4'),
            CharT('5'), CharT('6'), CharT('7'), CharT('8'), CharT('9'),
            CharT('A'), CharT('B'), CharT('C'), CharT('D'), CharT('E'),
            CharT('F') };

    typedef std::basic_string<CharT> string_type;
    string_type result(sizeof(value) * 2, 0);
    typename string_type::reverse_iterator iter = result.rbegin();
    while(value > Base)
    {
        *iter = lookup[value % Base];
        ++iter;
        value /= Base;
    }

    *iter = lookup[value];
    return result;
}
std::string to_hex_string_ethon4(unsigned value)
{
    typedef char CharT;
    const unsigned Base = 16;

    CharT const lookup[] =
    {
        CharT('0'), CharT('1'), CharT('2'), CharT('3'),
        CharT('4'), CharT('5'), CharT('6'), CharT('7'),
        CharT('8'), CharT('9'), CharT('A'), CharT('B'),
        CharT('C'), CharT('D'), CharT('E'), CharT('F')
    };

    std::array<CharT, std::numeric_limits<unsigned>::digits> buffer;
    auto iter = buffer.rbegin();
    while(value > Base)
    {
        *iter = lookup[value % Base];
        ++iter;
        value /= Base;
    }

    *iter = lookup[value];
    return std::basic_string<CharT>(iter.base(), buffer.end());
}
std::string to_hex_string_incognito(unsigned value)
{
    static std::string hex;
    hex.clear();
    do
    {
        if( value%16 < 10)
            hex += value%16 + '0';
        else if(value%16 > 9 && value%16 < 17)
            hex += value%16 + 55;
    } while(value /= 16);
    std::reverse(hex.begin(), hex.end());
    return hex;
}
template <typename T>
struct identity
{

    typedef T type;
};
template <std::size_t... i> struct index_list
    : identity<index_list<i...>> {};

template <typename T> struct append_index_list
    : append_index_list<typename T::type> {};
template <std::size_t... i> struct append_index_list<index_list<i...>>
    : identity<index_list<(i+1)..., 0>> {};

template <std::size_t N> struct make_index_list
    : append_index_list<make_index_list<N-1>> {};
template <> struct make_index_list<0>
    : identity<index_list<>> {};

template <typename T, std::size_t... i>
std::string to_hex_string_camper_(T value, index_list<i...>)
{
    const char lut[] = "0123456789abcdef";
    return std::string{ lut[(value>>(4*i))%16]... };
}
std::string to_hex_string_camper(unsigned value)
{
    return to_hex_string_camper_(value,make_index_list<(std::numeric_limits<unsigned>::digits+3)/4>::type());
}

#define MEASSURE( name )                                            \
    {                                                               \
        std::clock_t start = std::clock();                          \
        for( size_t i = 0; i < 2000000; ++i )                       \
            result = to_hex_string_##name( rand() );             \
        std::clock_t end = std::clock();                            \
        double elapsed = ( end - start ) / frequency;                      \
        std::cout << #name << '\t' << to_hex_string_##name(0x12345678) << '\t' << elapsed << std::endl; \
    }
int main()
{
    std::cout << RAND_MAX << std::endl;
    std::srand( static_cast< unsigned >( std::time( 0 ) ) );
    std::string result;
    double frequency = CLOCKS_PER_SEC;
    MEASSURE( swordfish );
    MEASSURE( hacker );
    MEASSURE( ethon );
    MEASSURE( ethon2 );
    MEASSURE( ethon3 );
    MEASSURE( ethon4 );
    MEASSURE( incognito );
    MEASSURE( camper );
}

    Mit -march=native (atom,64bit) und -O3 erhalte ich

    swordfish	12345678	2.14
hacker	12345678	9.96
ethon	12345678	1.95
ethon2	12345678	0.98
ethon3	12345678	0.97
ethon4	2345678	0.81
incognito	12345678	1.45
camper	12345678	0.8

    mit gcc-4.7, mit gcc-4.6.2 dagegen

    swordfish	12345678	2.81
hacker	12345678	13.38
ethon	12345678	2.29
ethon2	12345678	1.28
ethon3	12345678	1.27
ethon4	2345678	1.01
incognito	12345678	1.73
camper	12345678	1.13

    Der große Unterschied ist doch etwas überraschend.
    gcc-4.5.3

    swordfish	12345678	2.74
hacker	12345678	12.91
ethon	12345678	2.2
ethon2	12345678	1.24
ethon3	12345678	1.2
ethon4	2345678	1.02
incognito	12345678	1.68
camper	12345678	1.1
    0
  • ?

    Ihr könnt mich gleich rausnehmen, meine Version war nicht großartig überdacht 😃

    0

  • gut, ich wollte hier vorher nur zeigen, dass es performancetechnischer quatsch ist, den stringstream bei jedem call zu bauen und wieder zu zerstoeren - was campers benchmark NOCH deutlicher zeigt. Besser als mit einem lookup table wirds wohl kaum gehen, revidierte fassung zwecks performanceschwanzvergleich folgt...

    // edit:

    std::string to_hex_string_swordfish_2( unsigned value ) {
	const char lookup[ ] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
	char buffer[ 16 ];
	size_t i = 0;

	do {
		buffer[ i++ ] = lookup[ value % 16 ];
	} while( value /= 16 );

	return std::string( buffer, i );
}

    Meine letzte Messung:

    Swordfish:   596.335
Swordfish 2: 38.8694
Hacker:      1009.47
Ethon:       172.068
Ethon 2:     33.1679
Ethon 3:     50.1497
Incocnito:   69.6656
    0
  • E

    Bis darauf dass deins falsche Ergebnisse produziert. 😉

    int main()
{
	std::cout << to_hex_string_swordfish_2(0xDEADBEEF) << std::endl;
}

    Ergibt

    FEEBDAED

    So ... damit das Ganze mal sinnvoll wird, Boost.Spirit ist doch bei soetwas immer der King. Jemand da, der das mit Spirit drauf hat?

    0
  • H
     

    std::string to_hex_string_karma(unsigned p_unsigned)
{
	using boost::spirit::karma::generate;
	using boost::spirit::karma::hex;
	std::string result;
	std::back_insert_iterator<std::string> it(result);
	generate(it, hex(p_unsigned));

	return result;
}

    Kompiliert mit MSVC++ 10.0

    edit nochmal, hier die vergleichswerte. geht das noch besser in spirit?

    32767
swordfish       12345678        3.356
hacker          12345678        9.658
ethon           12345678        0.546
ethon2          12345678        0.109
ethon3          12345678        0.078  <- king
ethon4          2345678         0.172
incognito       12345678        0.218
karma           12345678        0.265
    0

  • Ethon schrieb:

    Bis darauf dass deins falsche Ergebnisse produziert. 😉

    ok, dann eben rückwärts (wenn Du nicht rückwärts lesen magst :p )

    std::string to_hex_string( unsigned value ) {
	const char lookup[ ] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
	char buffer[ 16 ];
	size_t i = 15;

	do buffer[ --i ] = lookup[ value % 16 ];
	while( value /= 16 );

	return std::string( buffer + i, 15 - i );
}
    0
  • 3

    Warum macht ihr's euch immer so kompliziert mit dem lookup, wie wärs mit:

    "0123456789ABCDEF"[value % 16]
    0
  • ?

    314159265358979 schrieb:

    Warum macht ihr's euch immer so kompliziert mit dem lookup, wie wärs mit:

    "0123456789ABCDEF"[value % 16]

    Sieht verdächtig einfach aus...

    0

  • Nana, des passt schon. Ich find's halt ned schön.

    0
  • ?

    Swordfish schrieb:

    Nana, des passt schon. Ich find's halt ned schön.

    In C++ ist schön, was komplex aussieht und dabei den Code verkürzt. 🤡

    0

  • Es is wurscht. Der Compiler macht eh aus beidem des gleiche.

    0
  • I

    Ich hab nochmal was neues probiert.

    std::string to_hex_string(long long val)
{
    std::string hex;
    const char inv[] = "0123456789abcdef";
    long long copy, size;
    copy = val;
    for(size = 0; copy /= 10; ++size);
    hex.resize(size);
    do
    {
        hex[size-((copy++)+1)] = inv[val%16];
    } while(val /= 16);
    return hex;
}

    Ich komm zwar nicht an ethon oder camper ran, aber wenigstens check ich meinen Code 🙂

    swordfish: 2000000 calls -> 1.065s
    incocnito: 2000000 calls -> 0.701s
    ethon3: 2000000 calls -> 0.509s
    camper: 2000000 calls -> 0.555s

    //edit
    static weggemacht

    0
  • T

    @Incocnito: Was sollen die static ohne const da? Die verhindern dass deine Funktion Thread Safe ist.

    0
Anmelden zum Antworten