Anzahl Elemente eines Vectors bestimmen



  • Hi

    Wie kann ich von size_type zu int umwandeln, ohne diese Warnung zu bekommen?

    warning C4267: '=' : conversion from 'size_t' to 'int', possible loss of data



  • Ich würds mal mit reinterpret_cast<int>(...) versuchen.

    Das du die Warnung bekommst ist klar, ich glaube size_t ist ein __int64 oder hat wenigstens einen ähnlichen Wertebereich (weiß gerade nicht genau, eventuell kann mich da jemand anders verbessern).



  • Sollte ich besser die int Variable in size_t abändern?
    Oder casten?



  • Kommt auf die Anwendung drauf an, wenn dein vector weniger als 2^32 Elemente hat, kannst du ruhig casten.

    Intressant wird der Datentyp size_t erst, wenn du zum Beispiel die größe von Dateien bestimmen willst. 2^32 entsprichen 4 GB, dann wäre mit casten Feierabend. Da es aber Dateien gibt die größer sind als 4 GB lohnt es sich in diesen Fällen size_t oder __int64 zu nutzen.

    Ich glaube gegen die Nutzung von size_t und __int64 spricht nur das ein 32 bit Prozessor diesen Datentyp nicht in einem Rechenzyklus verarbeiten kann, sondern zwei braucht. *nicht sicher bin*

    //edit: Ups, die aussage von oben ist nicht ganz zutreffend bei int geht der Werte bereich nur bis 2^31 (=2^32/2), da ja noch der negative Bereich hinzukommt. Eventuelle solltest du daher vieleicht besser mit unsigned int arbeiten (da hast du richtige 2^32 zur Verfügung)



  • Danke
    Ne ich denke so viele Elemente hab ich da nicht drin.
    Dann kann ich die Warnung einfach ignorieren oder?
    Wo find ich raus, was mein Kompiler für size_t definiert hat?



  • flammenvogel schrieb:

    Ich würds mal mit reinterpret_cast<int>(...) versuchen.

    Das ist Unsinn. reinterpret_cast ist dazu da um Zeiger zu casten.

    flammenvogel schrieb:

    Das du die Warnung bekommst ist klar, ich glaube size_t ist ein __int64 oder hat wenigstens einen ähnlichen Wertebereich (weiß gerade nicht genau, eventuell kann mich da jemand anders verbessern).

    Stimmt auch nicht. size_t ist meistens ein typedef auf unsigned int, also auf 32 Bit Systemen eben 32 Bit und auf 64 Bit Systemen (wie meinem) 64 Bit. Zum Beweis:

    $ sizeof size_t
    sizeof (size_t) == 64 Bit == 8 Byte
    $ CC=gcc32 sizeof size_t
    sizeof (size_t) == 32 Bit == 4 Byte
    

    wobei sizeof ein Shellskript mit diesem Inhalt ist:

    #!/bin/bash
    
    if [ $CC ]
    then
        compiler=$CC
    else
        compiler="gcc"
    fi
    
    if [ $CFLAGS ]
    then
        compiler="$compiler $CFLAGS"
    fi
    
    filename="/tmp/sizeof.c"
    arg=$1
    
    echo -n "const char* str = \"" > $filename
    echo -n "sizeof (" >> $filename
    echo -n $arg | sed "s/\"/\\\\\"/g"  >> $filename
    echo ") == %u Bit == %u Byte\\n\";" >> $filename
    
    echo "#include <stdio.h>
    #include <limits.h>
    int main ()
    {
        printf(str, sizeof ($arg) * CHAR_BIT, sizeof ($arg) * CHAR_BIT / 8);
    }" >> $filename
    if [ $VERBOSE ]
    then
        if $compiler $filename -o$filename.exe
        then
            res="1"
        fi
    else
        if $compiler $filename -o$filename.exe 2> /dev/null
        then
            res="1"
        fi
    fi
    
    if [ $res ]
    then
        $filename.exe
        rm $filename.exe
    else
        echo "sizeof ($arg) == unknown"
    fi
    rm $filename
    

    Ziemlich primitiv, aber äußerst praktisch ;).

    Die Warnung kommt möglicherweise, weil in ein int nur halbsoviele positive Werte passen wie in ein unsigned. Verwende unsigned oder size_t und die Sache ist gegessen.



  • 😮
    Hab kein Linux, daher Shellscript == unkonwn type 😃
    Mit unsigned int hab ichs versucht, is nich.
    Compiler ist übrigens VC8.0
    Mit size_t gehts ohne Warnung, aber wenn das stimmt:

    Ich glaube gegen die Nutzung von size_t und __int64 spricht nur das ein 32 bit Prozessor diesen Datentyp nicht in einem Rechenzyklus verarbeiten kann, sondern zwei braucht. *nicht sicher bin*

    möcht ich das nicht umbedingt.
    Hab nur ein 32 bitter *schwanzlängenvergleichverliersniff*



  • 1. OMG, was ist ein Rechenzyklus
    2. .filmor hat die Behauptung gerade wiederlegt.



  • @.filmor: Hmm, ich glaube ich habe size_t mit pos_type verwechselt, der müsste 64 Bit groß sein. Srry

    //edit: LordJaxom: eine etwas unglückliche Wortschöpfung von mir, außerdem bezieht sich die Behauptung auf 64 Bit Variabeln.



  • Class iker schrieb:

    Mit unsigned int hab ichs versucht, is nich.

    Das glaube ich dir nicht :p. Fehlermeldung?

    Class iker schrieb:

    Mit size_t gehts ohne Warnung, aber wenn das stimmt:

    Ich glaube gegen die Nutzung von size_t und __int64 spricht nur das ein 32 bit Prozessor diesen Datentyp nicht in einem Rechenzyklus verarbeiten kann, sondern zwei braucht. *nicht sicher bin*

    möcht ich das nicht umbedingt.
    Hab nur ein 32 bitter *schwanzlängenvergleichverliersniff*

    Das lässt sich ganz leicht herausfinden. Lass einfach dieses Programm laufen:

    #include <iostream>
    #include <limits>
    
    int main ()
    {
        std::cout << std::numeric_limits<std::size_t>::digits  << std::endl;
    }
    

    Das gibt dir die Größe von size_t aus.



  • flammenvogel schrieb:

    @.filmor: Hmm, ich glaube ich habe size_t mit pos_type verwechselt, der müsste 64 Bit groß sein. Srry

    Muss er auch nicht. Standardgemäß gibts bei den meisten 32-Bit Compilern AFAIK gar keine 64-Bit Typen (nur solche Erweiterungen wie __int64 oder long long). pos_type gibts außerdem nicht. Falls du difference_type meinst, das ist beim 32-Bit Compiler ein 32 Bits großer Integer.



  • .filmor schrieb:

    Class iker schrieb:

    Mit unsigned int hab ichs versucht, is nich.

    Das glaube ich dir nicht :p. Fehlermeldung?

    Mein Kompilierer schrieb:

    ------ Rebuild All started: Project: Blabla, Configuration: Debug Win32 ------
    Deleting intermediate and output files for project 'Blabla', configuration 'Debug|Win32'
    Compiling...
    Main.cpp
    PathGraph.cpp
    ...: warning C4267: '=' : conversion from 'size_t' to 'unsigned int', possible loss of data
    ...: warning C4267: '=' : conversion from 'size_t' to 'unsigned int', possible loss of data
    Generating Code...
    Compiling manifest to resources...
    Linking...
    LINK : ....exe not found or not built by the last incremental link; performing full link
    Embedding manifest...
    Build log was saved at "file://c:..."
    ALG_DijkstraWithBoost - 0 error(s), 2 warning(s)
    ========== Rebuild All: 1 succeeded, 0 failed, 0 skipped ==========

    :p Na gut, sis nur ne Warnung..



  • Dein kleines Testprogramm schrieb:

    32

    Leider nicht 42 😃
    Danke man, wieder was gelernt 👍



  • @.filmor: Ich meine den Datentyp der von fstream::teelg() ausgegen wird (nach meiner Referenz ist das pos_type). Der kann bei mit WinXP (gcc Kompiler) problemlos auch 64Bit Werte aufnehmen. Wäre das anderes wäre es in C++ nicht möglich mit Daten zu arbeiten, die größer als 4GB sind, was definitiv nicht der Fall ist.



  • ..(68) : warning C4832: token '.' is illegal after UDT 'std::numeric_limits<int>'
    ...\limits(653) : see declaration of 'std::numeric_limits<int>'

    S gibt sogar noch eine mehr, mit Deiner kleinen Testzeile 😃


Log in to reply