c++ variable Anzahl von for Schleifen

[Paulchen (Gast)]

Hallo

ich möchte in visual studio ein kleines c++ tool, das einen 
kleingeschriebenen Text liest (originalText) und dann alle Möglichkeiten 
ausgibt, mit jeweils einen großgeschriebenen Buchstaben. Das klappt so 
ganz gut:

for (int n = 0; n < Text_lenght; n++) {
    modifiedText1 = originalText;    
    modifiedText1[n] ^= 0x20;
    cout << modifiedText1 << endl;
}

Analog dazu gibt der folgende Code maximal 2 großgeschriebene Buchstaben 
aus:

for (int n = 0; n < Text_lenght; n++) {
    modifiedText1 = originalText;    
    modifiedText1[n] ^= 0x20;
    cout << modifiedText1 << endl;
    for (int m = n+1; m < Text_lenght; m++) {
      modifiedText2 = modifiedText1;
      modifiedText2[m] ^= 0x20;
      cout << modifiedText2 << endl;
      }
}

Natürlich kann man entsprechende Verschachtelungen auch für max.3, max.4 
usw anwenden.
Wie geh ich aber vor, wenn ich nun maximal n großgeschriebene Buchstaben 
möchte? Zum Beispiel dass n jeweils die Länge des Textes ist?

[Dr. Sommer (Gast)]

Mit Rekursion, d.h. einer Funktion welche sich selbst wieder aufruft.

[Paulchen (Gast)]

ich hab mich nun bzgl. Rekursion etwas eingelesen. Bei meiner 
Aufgabenstellung komme ich aber trotzdem nicht weiter, oder ich steh 
einfach auf dem Schlauch...

[foobar (Gast)]

Beispiel:

#include <stdio.h>
#include <stdlib.h>

void
foo(char *str, int i, int n)
{
    if (str[i] && n > 0)   
    {    
        str[i] ^= 0x20;
        printf("%s\n", str);
        foo(str, i+1, n-1);
        str[i] ^= 0x20;
        foo(str, i+1, n);
    }
}
    
int 
main(int argc, char **argv)
{   
    if (argc == 3) 
        foo(argv[1], 0, atoi(argv[2])); 
    
    return 0;
}

[foobar (Gast)]

Hmm... mit meinem Beispiel bin ich evtl etwas über's Ziel 
hinausgeschossen und mag einen Anfänger überfordern, deshalb hier ein 
etwas zugänglichere Version der Funktion foo.  Die Endrekursion, die 
hier nicht Thema ist, wurde durch eine Schleife ersetzt und es werden 
sprechende Namen benutzt:

void
grossklein(char *str, int ab_pos, int wieviele)
{        
    if (wieviele > 0)
        for (int i = ab_pos; str[i]; i++)
        {
            str[i] ^= 0x20;
            printf("%s\n", str);
            grossklein(str, i+1, wieviele-1);
            str[i] ^= 0x20;
        }
}

Die Rekursion ist klar zu erkennen und mit etwas Überlegung wird 
deutlich, dass durch sie bis zu wieviele Schleifen gleichzeitig 
aktiv sind.

Übung: Die Funktion so abändern, dass nur Strings, die exakt wieviele 
Zeichen geändert haben, ausgegeben werden.

[Paulchen (Gast)]

besten Dank!!

ich glaub ich hab viel zu komplizierte Überlegungen angestrengt :)

[Freddy (Gast)]

nur zur Info:
das was Du schreibst ist C-Code.
In C++ arbeitet man mit den STL wie dann z.B. Vector oder wenn Du in 
einem Framework z.B. Boost oder QT unterwegs bist mit deren Pendats.

[Peter D. (peda)]

Paulchen schrieb:
> modifiedText1[n] ^= 0x20;

Ich weiß ja nicht, wozu das gut sein soll, aber das wandelt auch 
Großbuchstaben und andere Zeichen um. Willst Du das so?

Besser ist daher toupper(), das wandelt nur a..z um und läßt alle 
anderen Zeichen in Ruhe.
Bzw. mit islower() kann man testen, ob ein Zeichen innerhalb a..z ist.

[Vn N. (wefwef_s)]

Erstmal sollte man das ganze in C++ schreiben wie eingangs gefordert, 
dann wirds auch gleich viel simpler...

Als einfaches Beispiel großschreiben des ganzen Strings:

#include <array>
#include <iostream>
#include <algorithm>
#include <cctype>

int main()
{
    const std::array<std::string, 2> textSnippets = {"testString123!?", "testString456()"};
    
    for(const std::string &snippet: textSnippets) {
        std::string modifiedText;
        modifiedText.resize(snippet.size());
        std::transform(snippet.begin(), snippet.end(), modifiedText.begin(), ::toupper);
        
        std::cout << snippet << "-->" << modifiedText << "\n";
    }
}

Runs as expected:

testString123!?-->TESTSTRING123!?
testString456()-->TESTSTRING456()

http://www.cpp.sh/6kj2d

Darauf aufbauend sollte es kein Problem sein, mit foobars Ansatz deine 
ursprüngliche Aufgabe zu lösen, nur halt in C++ statt C.