Kurze Frage , Kurze Antwort



  • Guten Morgen Leute,

    kurze Frage:

    Funktionen wie std::begin(XY) für ein normales Array, kann ich für "passed Arrays" nicht verwenden, oder stelle ich mich nur zu doof?

    void foo ( int myArr[], size_t size){
    
        auto beg = std::begin(myArr) ; //Error
    .....
    


  • Du hast da kein Array. C++ hat diese tolle Regel von C geerbt, wo [] in Parameterlisten ein Pointer ist. Geht also nicht.



  • Ok, dann werd ich auch keinen "Iterator" oder sowas übergeben können ?
    Kann das jetzt schlecht erklären aber sowas wie

    void foo(std::iterator::begin XY) //ist falsch schon klar

    geht auch nicht oder? Also es bleibt nichts über wie schon in C die Länge mit zu übergeben, oder evtl. einen Pointer auf Anfang und einen auf Ende zu übergeben?

    void foo(int *anf, int *end){
    
        while( anf != end){
    
         tu was
       }
    }
    

    Noch ne andere , evtl. persönliche Frage bezgl. Style :

    int *p   vs  int* p 
    
    int &r   vs  int& r
    

    Ich hab mir jetzt glaub ich Käse angewohnt, bei Pointern schreib ich int *p und bei Refernezen int& r ...



  • Du hast doch schon was du brauchst: Einen Zeiger und die Laenge.

    int* und int&, definitiv. Wer was anderes verwendet ist doof.



  • Du hast doch schon was du brauchst: Einen Zeiger und die Laenge.

    Ja schon, ich spiele aber mit Überladung rum, und da hab ich ne funktion "show" die soll hald mehrere Varianten können.

    Also sowas wie "void foo(std::iterator::begin XY)" ... Da geht nix oder?



  • Fuehr das mal weiter aus, mir ist nicht klar, was du vor hast.



  • Fuehr das mal weiter aus, mir ist nicht klar, was du vor hast.

    Mir auch nicht ganz, Jugend ( naja, nicht wirklich) forscht 😃

    Also :

    void foo ( int myArr[], size_t size){
    
        auto beg = std::begin(myArr) ; //Error
    .....
    

    Geht nicht. OK

    Kann man etwas in die Richtung

    void foo( SYNTAX UNBEKANNT x, SYNTAX UNBEKANNT){
    
       while (anf != ende){
         do sth. 
         anf ++;
       }
    }
    
    MAIN : 
    
    MyStruct myArray[5];
    
    auto beg = std::begin(myArray);
    auto end = std::end(myArray); 
    
    foo(beg, end);
    

    machen? std::begin(...) liefert ja nen Iterator zurück, kann ich den hernehmen wie nen "normalen" Pointer?

    dann wäre bei SYNTAX UNBEKANNT : void foo(MyStruct *x, MyStruct *y)

    oder muss man für den Iterator ne "spezial" Syntax benuzten ... void foo(std::keine_ahnung::irgendas x, ...)


  • Mod

    Entspricht irgendwas hiervon dem, was du suchst?

    #include <array>
    #include <iostream>
    using namespace std;
    
    void array_overload(array<int, 3>) {cout << "std::array Überladung, 3 int\n";}
    void array_overload(array<int, 2>) {cout << "std::array Überladung, 2 int\n";}
    template <size_t N> void array_overload(array<int, N>) {cout << "std::array Template, " << N << " int\n";}
    
    void array_pointer_overload(int (*)[3]) {cout << "Pointer auf Array Überladung, 3 int\n";}
    void array_pointer_overload(int (*)[2]) {cout << "Pointer auf Array Überladung, 2 int\n";}
    template <size_t N> void array_pointer_overload(int (*)[N]) {cout << "Pointer auf Array Template, " << N << " int\n";}
    
    void array_reference_overload(int (&)[3]) {cout << "Referenz auf Array Überladung, 3 int\n";}
    void array_reference_overload(int (&)[2]) {cout << "Referenz auf Array Überladung, 2 int\n";}
    template <size_t N> void array_reference_overload(int (&)[N]) {cout << "Referenz auf Array Template, " << N << " int\n";}
    
    int main()
    {
      std::array<int, 2> a_2;
      std::array<int, 3> a_3;
      std::array<int, 4> a_4;
    
      array_overload(a_2);
      array_overload(a_3);
      array_overload(a_4);
    
      int p_2[2];
      int p_3[3];
      int p_4[4];
    
      array_pointer_overload(&p_2);
      array_pointer_overload(&p_3);
      array_pointer_overload(&p_4);
    
      array_reference_overload(p_2);
      array_reference_overload(p_3);
      array_reference_overload(p_4);
    }
    

    PS: Bitte benutze aussagekräftige Threadnamen, die den Inhalt beschreiben, nicht irgendwelche Metainformationen. Vor allem, da hier wohl kaum von kurzer Frage und kurzer Antwort die Rede sein dürfte.



  • beg_offl schrieb:

    machen? std::begin(...) liefert ja nen Iterator zurück, kann ich den hernehmen wie nen "normalen" Pointer?

    Zeiger sind Iteratoren.
    begin liefert bei einem Array einen Zeiger zurück.

    Kellerautomat schrieb:

    int* und int&, definitiv. Wer was anderes verwendet ist doof.

    int * und int &, definitiv. Wer was anderes verwendet ist doof.



  • Zur Not machst dus wie die Standardbibliothek und machst halt Templates aus den Parametern:

    template<class It>
    void foo( It anf, It ende)
    {
    	while (anf != ende)
    	{
    		// do sth.
    		anf ++;
    	}
    }
    
    class MyStruct
    {};
    
    int main()
    {
    	MyStruct myArray[5];
    
    	auto beg = std::begin(myArray);
    	auto end = std::end(myArray);
    
    	foo(beg, end);
    
    	return 0;
    }
    

  • Mod

    Skym0sh0 schrieb:

    Zur Not machst dus wie die Standardbibliothek und machst halt Templates aus den Parametern:

    Das sollte nicht der Notfall, sondern der Normalfall sein. Ich bin gerade nur etwas verwirrt, ob der TE einen legitimen Grund hat, das nicht so zu machen, oder ob er das einfach nur nicht kennt.



  • SeppJ schrieb:

    Skym0sh0 schrieb:

    Zur Not machst dus wie die Standardbibliothek und machst halt Templates aus den Parametern:

    Das sollte nicht der Notfall, sondern der Normalfall sein. Ich bin gerade nur etwas verwirrt, ob der TE einen legitimen Grund hat, das nicht so zu machen, oder ob er das einfach nur nicht kennt.

    Sollte es echt der Normalfall sein? 😕
    Ich mein, man müsste die Funktion ja dann allgemein halten.

    Und eigentlich fehlen dann noch type_traits und sowas...



  • PS: Bitte benutze aussagekräftige Threadnamen, die den Inhalt beschreiben, nicht irgendwelche Metainformationen. Vor allem, da hier wohl kaum von kurzer Frage und kurzer Antwort die Rede sein dürfte.

    Sorry, kurze Frage und kurze Antwort war noch auf die Ursprüngliche Frage :

    kurze Frage:

    Funktionen wie std::begin(XY) für ein normales Array, kann ich für "passed Arrays" nicht verwenden, oder stelle ich mich nur zu doof?

    gedacht, hat sich bisschen weiterentwickelt sorry.

    SeppJ schrieb:

    Skym0sh0 schrieb:

    Zur Not machst dus wie die Standardbibliothek und machst halt Templates aus den Parametern:

    Das sollte nicht der Notfall, sondern der Normalfall sein. Ich bin gerade nur etwas verwirrt, ob der TE einen legitimen Grund hat, das nicht so zu machen, oder ob er das einfach nur nicht kennt.

    Ähm ja, wei ich das "einfach NOCH nicht kenne" 🙂

    Zeiger sind Iteratoren.
    begin liefert bei einem Array einen Zeiger zurück.

    Danke, das hilft mir jetzt erst mal weiter.

    @SeppJ :

    Entspricht irgendwas hiervon dem, was du suchst?

    Ja, das ist hilfreich, jedoch habe ich zur Syntx eine Frage :

    void array_pointer_overload(int (*)[3]) {cout << "Pointer auf Array Überladung, 3 int\n";}
    
    und 
    
    array_pointer_overload(&p_3);
    

    // array_pointer_overload erwartet jetzt einen Pointer auf ein Array mit 3 Ints... right? darum wird &p_3 und nicht p_3 (wäre nur ein Pointer auf auf ein int array , da der Name nur auf einen Pointer auf den Anfang zerfällt. ) immer noch right ?

    So, aber wie um alles könnte ich Elemente des Arrays mit dieser Funktionsdefinition in der Funktion benuzten?

    void array_pointer_overload(int (*)[3]){
         // Gib z.B: Element 2 aus : 
         // bräuchte ich da nicht  void array_pointer_overlaod(int (*)[3]irgendwas)
    

    Freitag Vormittags steh ich evtl. noch ein bisschen aufm Schlauch....



  • bzw. :

    void array_pointer_overload(int (*irgendwas)[3]){
    ..
    


  • void array_pointer_overload(int (*test)[3])
    {
        for(int i : *test)
        {
            cout << i << '\n';
        }
    }
    


  • Und wie ändert man da z.B. den wert [2] ?



  • Das wäre doch dann

    *(*test+2) = 45 ?? Das macht es Syntax Technisch nicht gerade leichter?



  • (*test)[2] = new_val;
    

    Referenzen auf Arrays sind da aber angenehmer, da spart man sich die Dereferenzierung.



  • wie würde das dann aussehen?



  • So oder :

    void array_pointer_overload(int (&test)[3], int item) {
    
    	std::cout << "with ref: \n"; 
    
    	std::cout << test[item];
    }
    

Anmelden zum Antworten