das ist ja auch wieder c++. passt aber generell zur gesamten verständnisfähigkeit der leute hier.

@razor sagte in switch case, römische zahlen, while schleife: @DirkB ```cpp printf("Geben Sie zwei Zahlen ein:\n"); scanf("%lf %lf", &zahl1, &zahl2); if (zahl1<2||zahl2<2) { printf("Die Eingabe ist unter zwei\n"); } habs so gemacht WTF? willst du überprüfen ob zwei Werte eingegeben wurden oder den Wertebereich der Eingabe?

@HarteWare Es ist also doch am schnellsten mit std::sort (wenn man std::sort, std::map und std::unordered_map betrachtet)? Korrekt. In Deinem Post fehlt glaub noch oben (aber ist ja nicht so wichtig...) std::sort[100] Ebenso korrekt. Ich hab' beim Kopieren wohl nicht weit genug hinaufgescrollt und zu wenig kopiert. Es fehlen auch noch alle 4 Einträge mit [10]. Aber ja, sollte reichlich egal sein, denn auch da schlagen beide Sorts beide Maps.

@Wade1234 ich hab mir vorhin nur ne skale 1-100 gemacht mit möglichen Wegen aber ich versuch das auch mal und nochmals danke an euch allen und eure geduld ich hab jetzt ne Vorstellung wo meine Fehler liegen und kann dann daran arbeiten

Es geht nicht um Sicherheit, sondern um Spaß beim Programmieren. Wenn ich GCC 4.9 einsetzen würde, würde ich mich pausenlos ärgern, dass ich all die neuen Features aus neuem C++ nicht benutzen könnte. Die Fehlermeldungen selbst sind auch sehr viel brauchbarer geworden. In diesem speziellen Fall bringt zwar auch der neueste GCC die gleiche verwirrende Meldung, aber so allgemein ist der GCC sehr viel weniger kryptisch als vor 5 Jahren.

@Wutz sagte in Laenge eines Struct-Arrays.: @SeppJ Du zeigt in der Diskussion um Arrays einen Zeiger auf ein Array und beschreibst dessen Verhaltensweisen. Ein Array ist kein Zeiger. Ein Zeiger ist kein Array. @Swordfish sagte in Laenge eines Struct-Arrays.: @SeppJ Sogesehen 1:0 Wutz. Häh? Ich rede von *foo, nicht foo. *foo ist vom Typ int[64], das ist Fakt, da gibt es nichts zu diskutieren und auch nichts abzustimmen.

Ja alles gut. Scheint hier ja normal zu sein

@Wade1234 Danke das war wirklich sehr hilfreich habe nie arrays von dieser Seite mit Konstanten betrachtet.

Wenn etwas eingegeben wird aus dem kein Integer extrahiert werden kann geht der stream in einen Fehlerzustand und gibt konvertiert zu bool false: #include <limits> // std::numeric_limits<> #include <cstddef> // std::size_t #include <cctype> // std::tolower() #include <numeric> // std::iota() #include <array> #include <iostream> std::istream& eat_whitespace_except_newline(std::istream &is) { for (int ch; std::isspace(ch = is.peek()) && ch != '\n'; is.get()); return is; } std::istream& ignore_line(std::istream &is) { return is.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); } std::istream& clear_and_ignore_line(std::istream &is) { is.clear(); return ignore_line(is); } int main() { std::array<int, 8> foo; std::iota(foo.begin(), foo.end(), 42); for (char again{ 'y' }; again == 'y'; std::cout.put('\n')) { std::size_t index; while (std::cout << "Index: ", !(std::cin >> index >> eat_whitespace_except_newline) || index >= foo.size() || std::cin.peek() != '\n') { std::cout << "Input error :(\n\n"; clear_and_ignore_line(std::cin); } std::cout << "foo[" << index << "]: " << foo[index] << '\n'; while (std::cout << "\nAgain? (y/n)\n", !(std::cin >> again >> eat_whitespace_except_newline) || (again = std::tolower(again)) != 'y' && again != 'n' || std::cin.peek() != '\n') { std::cout << "Input error :(\n\n"; clear_and_ignore_line(std::cin); } } }

@Lordkurd sagte in C-Programm Informatik 1: Dirk eine letzte Bitte das Programm so wie es da steht kannst du mir eine Zusammenfassung schreiben weil ich müsste das auch morgen erklären und bin mir einigen stelllen unsicher Sorry, aber ich habe heute schon mehr Hausaufgaben gemacht als ich sollte. Füge noch Kommentare ein, dann weißt du was du machen wolltest. Was da berechnet wird steht unter https://de.wikipedia.org/wiki/Logarithmus#Als_Potenzreihe

@mmm_1482_ Bitte nutze die Code-Tags: Code mit der Maus markieren und dann auf das </> Symbol oben (rechts neben C++ Auswahl) klicken. Willst du jetzt 0 bis 10 (11 Elemente pro Zeile/Spalte) oder 1 bis 10 (10 Elemente pro Zeile/Spalte) ausgeben. Bedenke, dass der Index immer bei 0 anfängt. Im Augenblick machst du die Berechnung für die Tabelle bei der Ausgabe. Ist etwas überflüssig. Was soll der Parameter (das i) bei printout? (Zeile 48ff) Warum zwei verschachtelte Schleifen, wenn du nur eine Zeile ausgeben willst. Das war doch schon gekärt wie das geht. @mmm_1482_ sagte in Tabelle erstellen mithilfe von Arrays: So sieht mein Code bislang aus. Fehlt halt echt nur dass an der Seite nochmal die Zahlen 1-10 mit ausgegeben werden Was hindert dich daran, die Zeile cout << row << "\t "; zwischen Zeile 24 und 25 einzubauen?

Ok vielen Dank für eure Hilfe, ich habs hinbekommen.

@SeppJ Klar von mir! danke f0r deine hilfe, aber ich werde erst morgen, also einige stunde später ausprobieren, F0r die jedem klar sehbahre codepostung danke ich extra. sehr sehr hilfsreich! Danke euch in der Fore°! jetzt aber mir schlafen angesagt

Da ist buchstäblich ein Link zu einer Bücherliste in meinem Beitrag

Falls Du Windows benutzt, hast Du hier etwas zum spielen: #include <windows.h> #include <array> using namespace std; // Spielfeld const int zeilen = 5; const int spalten = 7; using spielfeldTyp = array<int, zeilen * spalten>; //Regeln const int minAnzFuerNeu = 2; const int minAnzFuerErhalt = 2; const int maxAnzFuerErhalt = 3; //Ausgabeoffset const int spielfeldOffX = 3; const int spielfeldOffY = 15; const int nextOffX = 25; const int nextOffY = spielfeldOffY; // n paar Konsolefunktionen void SetCursorVisible(BOOL v) { CONSOLE_CURSOR_INFO ci; GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &ci); ci.bVisible = v; SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &ci); } void SetWindowExt(int x, int y, int yMulti = 1) { SMALL_RECT sr_window = {0, 0, static_cast<SHORT>(x) - 1, static_cast<SHORT>(y) - 1}; COORD extension; CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi); extension.X = max(x, csbi.dwMaximumWindowSize.X); extension.Y = max(y, csbi.dwMaximumWindowSize.Y); SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), extension); SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &sr_window); extension.X = x; extension.Y = y * yMulti; SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), extension); } void ClearScreen(WORD attribute = 7) { CONSOLE_SCREEN_BUFFER_INFO csbi; COORD target = {0, 0}; DWORD written; GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi); FillConsoleOutputCharacter(GetStdHandle(STD_OUTPUT_HANDLE), ' ', csbi.dwSize.X * csbi.dwSize.Y, target, &written); FillConsoleOutputAttribute(GetStdHandle(STD_OUTPUT_HANDLE), attribute, csbi.dwSize.X * csbi.dwSize.Y, target, &written); } void DruckSimpleText(int x, int y, char const *text) { COORD target = {static_cast<SHORT>(x), static_cast<SHORT>(y)}; DWORD written; WriteConsoleOutputCharacter(GetStdHandle(STD_OUTPUT_HANDLE), text, strlen(text), target, &written); } void DruckSimpleChar(int x, int y, char c) { char text[2] = {c, 0}; DruckSimpleText(x, y, text); } struct taste { taste(int c, int k) : AsciiChar(c), VirtualKey(k){}; int AsciiChar; int VirtualKey; }; taste getInput() { INPUT_RECORD ir; DWORD dummy; do { ReadConsoleInput(GetStdHandle(STD_INPUT_HANDLE), &ir, 1, &dummy); }while(ir.EventType != KEY_EVENT || !ir.Event.KeyEvent.bKeyDown); return taste(ir.Event.KeyEvent.uChar.AsciiChar, ir.Event.KeyEvent.wVirtualKeyCode); } // Funktionen zum Spiel void BerechneNextGeneration(const spielfeldTyp &spielfeld, spielfeldTyp &next) { next = spielfeld; for(int z = 0; z < zeilen; ++z) { for(int s = 0; s < spalten; ++s) { int nachbarn = 0; for(int pz = z - 1; pz < z + 2; ++pz) { for(int ps = s - 1; ps < s + 2; ++ps) { if(pz == z && ps == s //zu prüfendes Feld ausschließen || pz < 0 || ps < 0 //linker oder oberer Rand || pz > zeilen - 1 || ps > spalten - 1 //recher oder unterer Rand ) continue; if(spielfeld[pz * spalten + ps] == 1) nachbarn++; } } if(spielfeld[z * spalten + s] == 0 && nachbarn >= minAnzFuerNeu) next[z * spalten + s] = 1; if(spielfeld[z * spalten + s] == 1 && (nachbarn < minAnzFuerErhalt || nachbarn > maxAnzFuerErhalt)) next[z * spalten + s] = 0; } } } void WarteAufTaste() { getInput(); } void SpielfeldAusgeben(const spielfeldTyp &spielfeld, int xOffset = 0, int yOffset = 0) { for(int z = 0; z < zeilen; ++z) { for(int s = 0; s < spalten; ++s) { DruckSimpleChar(2 * s + xOffset, 2 * z + yOffset, spielfeld[spalten * z + s] + '0'); } } } int main() { // Spielfeld initialisieren spielfeldTyp spielfeld; spielfeldTyp nextGeneration; for(int i = 0; i < spalten * zeilen; ++i) spielfeld[i] = 0; SetWindowExt(60, 40); //Testwerte ins Spielfeld schreiben spielfeld[2 * spalten + 3] = 1; spielfeld[2 * spalten + 5] = 1; spielfeld[3 * spalten + 2] = 1; spielfeld[4 * spalten + 3] = 1; ClearScreen(); SetCursorVisible(false); DruckSimpleText(spielfeldOffX, spielfeldOffY - 3, "Spielfeld"); DruckSimpleText(nextOffX, nextOffY - 3, "naechste Gen."); BerechneNextGeneration(spielfeld, nextGeneration); SpielfeldAusgeben(spielfeld, spielfeldOffX, spielfeldOffY); SpielfeldAusgeben(nextGeneration, nextOffX, nextOffY); WarteAufTaste(); for(int i = 0; i < 10; ++i) { spielfeld.swap(nextGeneration); BerechneNextGeneration(spielfeld, nextGeneration); SpielfeldAusgeben(spielfeld, spielfeldOffX, spielfeldOffY); SpielfeldAusgeben(nextGeneration, nextOffX, nextOffY); WarteAufTaste(); } SetCursorVisible(true); }

Der "bloat" wäre mir derzeit egal. Die Lesbarkeit hatte in dem Moment für mich Vorrang und die ist halt bei std::pair/std::tuple eher mittelmäßig.

Der einzige garantiert mit der WinAPI kompatible compiler ist ein C++-Compiler der nur lausig C spricht. Ach, weißt was? Schreib's in Assembler.

@yahendrik Ohja, danke. Ich wusste nicht, dass es an dem PostQuitMessage(0) liegt. Nun funktioniert es, wie ich es mir vorgestellt habe Danke an alle Antworten!

@DirkB sagte in Sind alles Variante identisch: sizeof ist keine Funktion sondern eine Anweisung, daher braucht es auch keine Klammern. sizeof ist keine Anweisung. Das ist ein Schlüsselwort, mit dem ein Ausdruck gebildet wird, also bestenfalls vielleicht ein Operator.

@Mechanics Sorry, hast recht. Habe es gerade überprüft. Ich habe da wohl etwas durcheinandergebracht.