Array deklarieren



  • Hallo,

    ich möchte ein Array deklarieren und zwar indem ich ihm sage wie viele Werte es hat und dann einen Anfangspunkt, einen Endpunkt und eine Schrittweite angebe. Geht das in C bzw. C++? Also ich meine das in etwas so (Pseudocode):

    int array[5]={von 1, in 1er Schritten, bis 5}
    

    Versteht ihr was ich meine? In MATLAB gibts das so schön:

    array=(1:1:5);
    

    Ich kenne leider keine Syntax in C++ dafür. Bin über jede Info glücklich.

    Gruß,
    Laura



  • Da musst du wohl eine kleine Schleife basteln (kannste ja zwecks Wiederverwendung in eine Funktion packen):

    for(int i=0;i<5;++i) myArray[i]=i+1;
    


  • Okay, verstehe. Was ist allerdings wenn ich immer in 1/16 Schritten gehen will und zwar von 0 bis 0.1? ++i zählt ja immer um 1 nach oben. Muss ich dann einfach zwei Schleifen basteln und der einen sagen zähl von 0 bis 0.1 in 1/16 Schritten und der anderen an welche Stelle im Array es geschrieben werden soll?



  • Passt sowas hier vielleicht?

    #include <vector>
    
    void func(std::vector<double>& vec,double range_min,double range_max,int steps) {
    	for(int i=0;i<steps+1;++i) {
    		vec.push_back(i*(range_max-range_min)/steps);
    	}
    }
    
    int main() {
    	std::vector<double> vec;
    	func(vec,0.,1.,16);
    }
    


  • _matze schrieb:

    Passt sowas hier vielleicht?

    Das kann schon sein, genau kann ich es aber nicht sagen, da ich den Code nicht so richtig verstehe. 😕

    Also du erschaffst einen Vector, der ja ein dynamisches Array ist, richtig?
    Die Werte, die du hier

    func(vec,0.,1.,16);
    

    übergibst, was sollen die Punkte?
    Und kann ich bei "steps" dann nicht einfach "1/16" eingeben? Also so:

    func(vec,0,0.1,1/16);
    

    Die Rechnung in der Funktion verstehe ich auch nicht. Die rechnet ja immer den selben Wert aus und multipliziert ihn dann mit 1, 2, 3, ....
    Wozu braucht man dass denn?

    Sorry wenn ich das nicht verstehe, aber bitte hab Nachsicht, ich programmier noch nicht sehr lange. 😞



  • laura84 schrieb:

    Und kann ich bei "steps" dann nicht einfach "1/16" eingeben? Also so:

    func(vec,0,0.1,1/16);
    

    Einfache Antwort: Klar. Nur halt 1.0/16.0. Und step müßte ein double sein.

    Richttige Antwort: Nein! Kommazahlen als step bringen Dich in Teufels Küche. Wenn Du mal von 0 bis 1 mit step 0.05 und mit step 0.1 gemacht hast, weißt Du, was eich meine. Rundungsfehler.



  • Was meine Funktion macht, ist Folgendes:

    Du gibst an, von wo bis wo dein Wertebereich gehen soll (also z.B. von 0.0 bis 1.0). Und du gibst an, wieviele Schritte verwendet werden sollen. Eine 16 bedeutet, dass du in 1/16er Schritten das Array bzw. den vector füllen willst. Das sind dann 17 Elemente, die dem vector hinzugefügt werden, damit es auch von 0.0 bis glatt 1.0 geht (und nicht bis 1.0-1.0/16).

    Vielleicht wird es deutlicher, wenn du mal eine Ausgabe siehst:

    #include <iostream>
    #include <vector>
    
    void func(std::vector<double>& vec,double range_min,double range_max,int steps) {
    	for(int i=0;i<steps+1;++i) {
    		vec.push_back(i*(range_max-range_min)/steps);
    	}
    }
    
    int main() {
    	std::vector<double> vec;
    	func(vec,0.,1.,16);
    	for(unsigned int i=0;i<vec.size();++i) std::cout << vec[i] << std::endl;
    	system("pause");
    }
    

    Wenn das nicht das ist, was du wolltest, sag bescheid (und erklär es nochmal genau).

    std::vector ist quasi ein dynamisches Array, ja. Das ist hier einfach komfortabler, als ein Array mit new zu deklarieren (sonst müsste der Aufrufende selbst die Anzahl der Elemente bestimmen und sich um das Freigeben des Speichers kümmern).

    Die Punkte bedeuten einfach, dass wir hier double-Literale (oder -Konstanten) notieren.

    5    //integer-Literal
    5.   //double-Literal
    5.0  //identisch mit 5. (wenn es für dich lesbarer ist, schreib ruhig 5.0)
    .5   //auch ein double-Literal
    0.5  //identisch mit .5)
    5.f  //float-Literal
    5.0f //identisch mit 5.f
    

    Das kann wichtig sein, wenn du mit solchen Werten rechnest:

    //falsch:
    
    double d=1/2;   //da du hier mit integer-Werten rechnest, wird eine Ganzzahlendivision durchgeführt, die 0 ergibt (1 durch 2 = 0 Rest 1).
                    //Die 0 wird implizit nach double (Typ von d) gecastet (ist dann 0.0) und man wundert sich, warum 1/2 plötzlich 0 sein soll. ;)
    
    //richtig:
    
    double d=1.0/2;  //da hier ein Element des Ausdrucks ein double-Wert ist, ist das Ergebnis des Ausdrucks auch vom Typ double. Das Ergebnis ist dann 0.5, wie erwartet.
    

    EDIT: Und system("pause") habe ich jetzt nur der Einfachheit halber da 'reingepackt. Hier in den FAQ kannst du nachlesen, warum man das lieber nicht machen sollte und welche Alternataiven es gibt (für erste Gehversuche, und um dich nicht unnötig zu verwirren, finde ich es aber in Ordnung).



  • Wahnsinn, vielen vielen Dank!!!

    Das ist genau das was ich brauche. Und die Erklärung dazu war perfekt. Jetzt verstehe ich es und noch so einiges mehr.

    Danke für eure Mühen!



  • Gern geschehen.

    Falls du mehr über STL-Container wie std::vector wissen willst, gibt es hier einen netten Artikel zu dem Thema:

    http://www.c-plusplus.net/forum/viewtopic-var-t-is-143816.html
    (Teil 2+3 sind verlinkt)

    Aber lass dich nicht vom Artikel erschlagen. Es ist einfacher, als es vielleicht zunächst den Anschein hat, und bei einem std::vector kannst du auch erstmal auf Iteratoren verzichten und ihn fast wie ein normales Array behandeln. Trotzdem ist es vielleicht ganz interessant, mal in die Möglichkeiten 'reinzuschnuppern (so 'ne map kann richtig praktisch sein).


Log in to reply