C++ Array "inline" erzeugen und an Methode übergeben?

[Klaus M. (klaus_me)]

Hi! Ich bin in C++ nicht so firm. Geht sowas in C++ (inzwischen) 
irgendwie?
Ich benutze gcc/g++ 13

include <iostream>

void proc(const int arr[]) 
{
    for (int i = 0; arr[i] != 0; i++)
        std::cout << arr[i] << " "; 
    std::cout << std::endl;
}

int main() 
{
    const int array[] = {1, 2, 3, 0}; 

    proc(array); // Geht!
    proc({1,2,3,0}); // Geht das irgendwie auch?
}

[Scyte R. (scyte)]

Ohne die Frage gelesen zu haben, nimm std::array<int>.

[Klaus M. (klaus_me)]

Ok, ich habe aber variable Listen. Aber mit std::vector gehts wohl!
Ts... das kommt davon wenn man in den 80er C gelernt hat und C++ nie 
gescheit...

Danke!

#include <iostream>
#include <vector>

void proc(std::vector<int> arr) 
{
    for (auto id = arr.begin(); id != arr.end(); id++)
        std::cout << *id << " "; 
    std::cout << std::endl;
}

int main() 
{
    std::vector<int> vec{1, 2, 3, 0}; 

    proc(vec); // Geht!
    proc({1,2,3,0}); // Geht auch!
}

[Johann L. (gjlayde)]

Klaus M. schrieb:

>     for (auto id = arr.begin(); id != arr.end(); id++)
>         std::cout << *id << " ";

Oder einfach:

    for (int id : arr)
        std::cout << id << " ";

Ob man für sowas dynamische Speicherallkation verwenden will, was 
std::vector ja mit sich bringt, ist natürlich ne andere Frage.  Bei 
"PC-Programmieung" wohl kein allzu großer Haken...

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Klaus M. schrieb:
> Hi! Ich bin in C++ nicht so firm. Geht sowas in C++ (inzwischen)
> irgendwie?

#include <iostream>
#include <iterator>
#include <initializer_list>

template < typename Iter >
void proc_impl( Iter begin, Iter end )
{
    for ( ; begin != end && *begin; ++begin )
        std::cout << *begin << " ";

    std::cout << std::endl;
}

template < typename T >
void proc( const T& v )
{
    proc_impl( std::begin( v ), std::end( v ) );
}

template < typename T >
void proc( std::initializer_list< T > v )
{
    proc_impl( std::begin( v ), std::end( v ) );
}

int main()
{
    const int array[] = {1, 2, 3, 0};
    proc(array); // Geht!
    proc({1,2,3,0}); // Geht das irgendwie auch?
}

[Klaus H. (klummel69)]

Der Beispielcode von Torsten gibt proc({1,2,3,0}) falsch aus.

Grund ist Zeile 8:

for ( ; begin != end && *begin; ++begin )

Das Prüfen von *begin bewirkt, dass bei einer 0 im Array die Schleife 
abgebrochen wird.
Besser:

for ( ; begin != end; ++begin )

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Klaus H. schrieb:
> Der Beispielcode von Torsten gibt proc({1,2,3,0}) falsch aus.

Das war, was Klaus M. bestellt hatte.

[Klaus H. (klummel69)]

Torsten R. schrieb:
> Das war, was Klaus M. bestellt hatte.

Sorry, Du hast Recht, so wie er den Beispielcode gebaut hat, fällt die 0 
weg.
Ich bezweifle allerdings, dass das auch wirklich seine Intention war.

proc({1,2,3,0,5,2,9,0,3,1}) wird zu proc({1,2,3})

Es geht doch nichts über gescheit formulierte Anforderungen... 🙂

[Johann L. (gjlayde)]

Klaus H. schrieb:
> Torsten R. schrieb:
>> Das war, was Klaus M. bestellt hatte.
>
> Sorry, Du hast Recht, so wie er den Beispielcode gebaut hat, fällt die 0
> weg.
> Ich bezweifle allerdings, dass das auch wirklich seine Intention war.

NULL oder 0 als Ende-Marker wenn die Anzahl der Elemente nicht bekannt 
ist, ist so unüblich nicht. Im originalen Code war genau das der Fall, 
d.h. proc() hatte keine andere Möglichkeit das Ende des Arrays zu 
erkennen.

[Peter D. (peda)]

Johann L. schrieb:
> NULL oder 0 als Ende-Marker wenn die Anzahl der Elemente nicht bekannt
> ist, ist so unüblich nicht.

getchar benutzt z.B. EOF (-1) als Endezeichen. Damit trotzdem jeder 
8Bit-Wert gelesen werden kann, wird der Rückgabewert von unsigned char 
nach int gecastet.

[Rolf M. (rmagnus)]

Peter D. schrieb:
> Johann L. schrieb:
>> NULL oder 0 als Ende-Marker wenn die Anzahl der Elemente nicht bekannt
>> ist, ist so unüblich nicht.
>
> getchar benutzt z.B. EOF (-1) als Endezeichen.

getchar iteriert aber nicht über ein Array. Es gibt EOF zurück, wenn 
stdin geschlossen wurde.

Peter D. schrieb:
> Damit trotzdem jeder 8Bit-Wert gelesen werden kann, wird der Rückgabewert
> von unsigned char nach int gecastet.

EOF muss nicht zwingend -1 sein nach standard. Es muss nur negativ sein. 
Es ist auch nicht garantiert, dass es keinen gültigen Wert für char 
darstellt. Deshalb gibt es zusätzlich die Funktion feof().

[Klaus M. (klaus_me)]

Torsten R. schrieb:
> Das war, was Klaus M. bestellt hatte.

Korrekt, die "0" ist kein Inhalt, der regulär vorkommt und soll als 
Endmarker herhalten. Mir ist inzwischen klar, dass ich das gar nicht 
brauche und verwende es auch nicht mehr:

void RenderArea::drawNote(QPainter *painter, enum NH nh, int32_t xs, int32_t n, int32_t vel, std::vector<int> check_notes)
{
  ...
  if (check_notes.empty() == false)
  {
    // Step through all the notes
    for (int chk_note : check_notes)
    { 
    ...
    }
  }
}

Danke an alle Beteiligten!

[Rolf M. (rmagnus)]

Klaus M. schrieb:
> void RenderArea::drawNote(QPainter *painter, enum NH nh, int32_t xs,
> int32_t n, int32_t vel, std::vector<int> check_notes)

Du solltest dir überlegen, den vector per Referenz zu übergeben, denn 
sonst wird er jedes mal für den Funktionsaufruf komplett in einen neuen 
vector kopiert.

[Oliver S. (oliverso)]

Und wenn er nicht verändert wird, als const&

Oliver

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Und wenn wir schon beim Code-Review sind:
- Den unnötigen Test auf .empty() weg lassen, weil überflüssig.
- Den ! Operator verwenden, wenn ein boolscher Ausdruck negiert werden 
soll.

;-)

[Daniel A. (daniel-a)]

Die C variante wäre: proc((int[]){1,2,3,0})