Array Initialisierung



  • Kann man ein Array noch einfach mit 'A' initialisieren?

    char value[200];
            for(int i=0;i<sizeof(value);i++)
            {
                 value[i]='A';
            }
    

    Beim Vector würde ich das so machen aber beim Array geht das ja nicht:

    vector<char>var(200,'A');
    


  • std::fill?

    std::fill(&value[0],&value[sizeof(value)-1],'A');
    


  • _matze schrieb:

    std::fill(&value[0],&value[sizeof(value)-1],'A');
    

    Oder in dem konkreten Beispiel (vielleicht noch ein klein wenig leserlicher):

    std::fill(std::begin(value), std::end(value), 'A');
    


  • Mit c++-11 geht auch das:

    std::array<char,200> value;
    value.fill( 'A' );
    


  • std::fill(&value[0],&value[sizeof(value)-1],'A');
    
    std::fill(value, value + sizeof(value), 'A');
    


  • manni66 schrieb:

    Mit c++-11 geht auch das:

    std::array<char,200> value;
    value.fill( 'A' );
    

    Ja, aber er möchte ein echtes Array, keinen Container.



  • _matze schrieb:

    std::fill?

    std::fill(&value[0],&value[sizeof(value)-1],'A');
    

    Warum lässt du das letzte Element aus?

    Sone schrieb:

    manni66 schrieb:

    Mit c++-11 geht auch das:

    std::array<char,200> value;
    value.fill( 'A' );
    

    Ja, aber er möchte ein echtes Array, keinen Container.

    Wer hat das gesagt?
    Vielleicht wusste er nicht, dass er std::array möchte. Er wusste ja auch nicht, wie man ein Array befüllt.

    Sone schrieb:

    std::fill(&value[0],&value[sizeof(value)-1],'A');
    
    std::fill(value, value + sizeof(value), 'A');
    

    Beides ist Mist, denn bei einer Änderung des Elementtyps ist sizeof(value) wahrscheinlich nicht mehr zufällig die Array-Länge.


  • Mod

    noch zum Spass:

    #include <array>
    #include <cstddef>
    
    template <char... c> struct xlist {};
    template <std::size_t N, typename = xlist<>> struct make_xlist;
    template <std::size_t N, char... i> struct make_xlist<N, xlist<i...>>
        : make_xlist<N-1, xlist<'\0', i...>> {};
    template <char... i> struct make_xlist<0, xlist<i...>>
    {
        typedef xlist<i...> type;
    };
    
    template <typename T, std::size_t N, char... i>
    std::array<T, N> make_array_(const T& v, xlist<i...>)
    {
        std::array<T, N> r = { ( (void)i, v )... };
        return r;
    }
    
    template <typename T, std::size_t N>
    std::array<T, N> make_array(const T& v = T())
    {
        return make_array_<T, N>( v, typename make_xlist<N>::type() );
    }
    
    std::array<char,200> value = make_array<char, 200>( 'A' );
    


  • Was ist das? Ist das noch C++, sieht aus wie RSA verschlüsselt^^



  • Warum nicht direkt das Array returnen? Und gar kein identity-struct, ich bin enttaeuscht. 😉



  • camper schrieb:

    noch zum Spass:

    std::array<char,200> value = make_array<char, 200>( 'A' );
    

    Ich muss doch stark bitten.

    template <std::size_t N, typename T> //argument deduction erlauben
    std::array<T, N> make_array(const T& v = T())
    {
        return make_array_<T, N>( v, typename make_xlist<N>::type() );
    }
    
    auto value = make_array<5>( 'A' ); //2x type/argument decution nutzen ;)
    

  • Mod

    Kellerautomat schrieb:

    Warum nicht direkt das Array returnen?

    Geht nicht standardkonform (korrekte Klammerung unspezifiziert). Deshalb wird es leider auch nichts mit constexpr.


Log in to reply