Zähler aktualisieren



  • Hallo,

    ich scheitere seit einer kleinen Ewigkeit an einem doch profanen Problem. Wie kann ich unteren Zähler berechnen?

    for (int i=0; i<5; i++)
        {
            for (int j=0; j<10; j++ )
            {
                std::cout << "zaehler: " << ??? << '\n';
            }
        }
    

    Das Einzige, was mir eingefallen ist, einfach einen entsprechenden Zähler zu installieren:

    int counter = 0;
    
    for (int i=0; i<5; i++)
        {
            for (int j=0; j<10; j++ )
            {
                std::cout << "zaehler: " << counter++ << '\n';
            }
        }
    

    Das scheitert aber dann, wenn ich zwei arrays durchzähle. Und ich den Zähler als Index für ein weiteres array benötige.

    int counter = 0;
    int z = 3;
    
    for (int i=0; i< a[z]; i++)
        {
            for (int j=0; j< b[z]; j++ )
            {
                std::cout << "zaehler: " << z ??? counter << '\n';
            }
        }
    


  • Zumindest mir ist nicht klar, was 'zaehler' denn nun eigentlich zählen soll...



  • Soll "zaehler" die Anzahl der Gesamtiterationen sein? Dann kannst du doch deine erste Methode weiter benutzen. Oder du berechnest es über

    zaehler = i*a[z]+j;
    


  • asdfasd schrieb:

    Soll "zaehler" die Anzahl der Gesamtiterationen sein?

    Genau, danke.

    Gibt es da keine andere Möglichkeit, als selbst diesen Zähler zu installieren? Bei Deinem Beispiel errechnet die Formel leider auch nicht mehr als der counter.

    Aus Umständen, wie die arrays erzeugt wurden, benötige ich aber einen Zusammenhang zwischen dem Index z und dem counter.



  • Jockelx schrieb:

    Zumindest mir ist nicht klar, was 'zaehler' denn nun eigentlich zählen soll...

    dto.

    @lemon03: Ein minimales (kompilierfähiges) Beispiel wäre gut. Und an dem zeigst Du uns dann, was Du gerne hättest.



  • zaehler = i*10 + j;
    


  • @ Furble Wurble

    Gut, will ich mal versuchen. Aber das ist nicht so einfach, weil die Inhalte der arrays bzw Container aus einer Datei gelesen werden. Und ich kann mir nicht vorstellen, das jemand nur zum testen extra eine Datei anlegen möchte?

    Aber vielleicht hilft ja schon ein Blick darauf, um zu erkennen, ob ich mir die Sache vielleicht ganz umsonst so schwer mache.

    Ein Teil der Datei sieht zB so aus:

    flf2a$ 7 7 20 -1 3 [95]
    banner4 by Merlin Greywolf merlin@brahms.udel.edu
    August 9, 1994
    
    4
    ...@
    ...@
    ...@
    ...@
    ...@
    ...@
    ...@@
    .####@
    .####@
    .####@
    ..##.@
    .....@
    .####@
    .####@@
    .####.####@
    .####.####@
    ..##...##.@
    ..........@
    ..........@
    ..........@
    ..........@@
    ...##.##..@
    ...##.##..@
    .#########@
    ...##.##..@
    .#########@
    ...##.##..@
    ...##.##..@@
    ..########.@
    .##..##..##@
    .##..##....@
    ..########.@
    .....##..##@
    .##..##..##@
    ..########.@@
    .#####...##..@
    .##.##..##...@
    .#####.##....@
    ......##.....@
    .....##.#####@
    ....##..##.##@
    ...##...#####@@
    ...####...@
    ..##..##..@
    ...####...@
    ..####....@
    .##..##.##@
    .##...##..@
    ..####..##@@
    

    Das ist im Ganzen ein Zeichensatz mit 95 Zeichen. Die obige 4 habe ich eingefügt, sie soll die Anzahl der einzulesenden Zeichen sein. Zum Testen wollte ich nicht immer alle einlesen.

    Um ein Zeichen im Speicher "abzubilden", habe ich ein struct gewählt.

    struct Char
    {
        int dim_x; //Breite des Zeichen
        int dim_y = charHeight; //Höhe des Zeichen (im Moment noch eine globale Variable)
        std::vector <bool> bit; //die "Pixel" des Zeichen als bit-muster
    };
    

    Und dieses in einen vector getan

    std::vector <Char> char_mask;
    

    Der Sinn dahinter soll sein, das char_mask[i] in Gänze ein ganz bestimmtes Zeichen darstellt.

    Einlesen tue ich es so. (Die gesamten cout-Ausgaben dienen nur mir, um einen gewissen Überblick zu behalten) Und da fängt es an schwierig für mich zu werden (ich bin mir nicht sicher, ob 'ch.bit.push_back();' das ist, was ich eigentlich bezwecken will):

    std::vector <std::string> bit_str;
        std::string str;
        std::getline(file, str);
        std::getline(file, str);
        std::getline(file, str);
        file.get();
    
        int str_dim;
        file >> str_dim;
        std::cout << "str_dim: " << str_dim << '\n';
    
        for (size_t i=0; i<str_dim*charHeight+1; i++)
        {
            std::getline(file, str);
            bit_str.push_back(str);
        }
    
        std::cout << "eingelesen" << '\n';
    
        Char ch;
        int counter = 0;
        for (size_t i=1; i<bit_str.size(); i+=charHeight)
        {
            for (size_t y=0; y<charHeight; y++)
            {
                ch.dim_x = bit_str[i].size();
                std::cout << "Zaehler: " << i+y << " Index: " << i/charHeight << " " << bit_str[i+y] << " " << ch.dim_x << '\n';
                for (int x=0; x<ch.dim_x; x++)
                {
                    if (bit_str[i+y].at(x) == '#')
                    {
                        //std::cout << "Zaehler: " << i+y << " Index: " << i/charHeight << " " << bit_str[i+y] << " " << ch.dim_x << " bit: " << '#' << '\n';
                        ch.bit.push_back(true);
                    }
                    else
                    {
                        //std::cout << "Zaehler: " << i+y << " Index: " << i/charHeight << " " << bit_str[i+y] << " " << ch.dim_x << " bit: " << '-' << '\n';
                        ch.bit.push_back(false);
                    }
                }
    
            }
            std::cout << "counter: " << counter++ << '\n';
            char_mask.push_back(ch);
        }
        std::cout << "mask.size: " << char_mask.size() << '\n' << '\n';
    

    Solange ich diese Struktur ausgebe, wie ich sie eingelesen habe, ist alles in Ordnung:

    counter = 0;
            for (int i=0; i<char_mask.size(); i++)
            {
                for (int j=0; j<char_mask[i].dim_y; j++)
                {
                    std::cout << "index: " << i << " y: " << j << " dim_x: " << char_mask[i].dim_x << " ";
                    for (int k=0; k<char_mask[i].dim_x; k++)
                    {
                        std::cout << char_mask[i].bit.at(counter++);
                    }
                    std::cout << '\n';
                }
            }
    

    Aber sobald ich einen beliebigen Index wähle, kommt nur Kram raus, weshalb ich diese 'counter'-Konstruktion beschuldige.

    (Sorry für den ganzen Text)



  • Ich hab mir jetzt nur das letzte Beispiel angeguckt, aber so braucht man die counter Variable nicht:

    int idx = char_mask[i].dim_y*char_mask[i].dim_x*i + char_mask[i].dim_x*j + k;
    std::cout << char_mask[i].bit.at(idx);
    

    Kurz ist aber was anderes, daher hab ich mal nicht alles in eine Zeile geschrieben.



  • Danke schön, erstmal 😉 Aus Erfahrung weiß ich inzwischen, das die Antworten in der Regel korrekt und hilfreich sind.

    Muss im Moment aber ne kleine Pause machen, melde mich dann wieder



  • Bei genauerer Betrachtung von deinem Code fällt mir noch ein Fehler auf. Du sagst Char ch soll ein Zeichen darstellen aber dein Code füllt das gleiche Char Objekt mit allen Zeichen, da du es zwischendurch nicht wieder zurück setzt. Entweder muss das Char ch in die for (size_t i=1; i<bit_str.size(); i+=charHeight) Schleife über alle Zeichen oder du löscht die ch Variable nach dem push_back. Dann lautet der Code mit deiner counter Variable auch nur noch so:

    std::cout << char_mask[i].bit.at(char_mask[i].dim_x*j + k);
    


  • Oha! Na danke für den Adlerblick und Korrektur.

    Läuft jetzt wie gewünscht, danke 😉



  • Uh, doch noch ne kleine Zusatzfrage.

    Der erste Tipp läuft zwar wie gesagt wie gewünscht, würde aber doch gerne wissen, wie ich ch löschen kann 🙂

    Einfach 'delete ch' scheint ja nicht zu reichen?



  • Der wird gelöscht (und sein destruktor aufgerufen) sobald er aus dem Scope (zwischen {}) fällt l.



  • Mit löschen meinte ich eigentlich den Inhalt des vectors im Char struct. Also ein

    ch.bit.clear();
    

    nach dem char_mask.push_back(ch); .



  • sebi707 schrieb:

    Mit löschen meinte ich eigentlich den Inhalt des vectors im Char struct. Also ein

    ch.bit.clear();
    

    nach dem char_mask.push_back(ch); .

    Oder wenn C++11 verfügbar ist sollte auch ein

    char_mask.emplace_back(std::move(ch));
    

    das gleiche erzeugen. Und man spart sich hier eine kopie



  • Wunderbar, danke nochmal.

    PS: Das ist halt sone Sache mit dem unvollständigen Sprachschatz bei Ungeübten 😉


Log in to reply