Aber meistens bringt es Übersicht (und zwar nicht nur in main) logisch zusammenhängende Befehle in Funktionen auszulagern.

Bsp:
Du willst z.B. für ne simple GUI auf KOnsolenebene eine Überschrift ausgeben:

int main()
{
    // ...
    cout << "+---------------------------------------------------" << endl;
    cout << "+---------------------------------------------------" << endl;
    cout << "+--------------Hallo ich bin der Peter--------------" << endl;
    cout << "+---------------------------------------------------" << endl;
    cout << "+---------------------------------------------------" << endl;
    // ...
}

Sowas auszulagern bringt meistens mehr Übersicht. Und klar, wie du sagst, sobald du diese Funktionalität mehrmals benötigst, hast du schon was gewonnen.

meiner pers. Meinung nach ... ja!
Man sollte zusammengehörende Blöcke in einzelne Funktionen packen, auch wenn sie am Anfang nur ein einziges Mal aufgerufen werden.

a) unter Umständen kann man sie ja später doch nochmal verwenden
b) erhöht es halt ungemein die Lesbarkeit

Gruß

Sollte man Funktionen in Funktionen aufrufen?
Also ich habe eine Funktion_1 in der ich Funktion_2 aufrufe und in Funktion_2 rufe ich Funktion_3 auf.
Sollte man das so machen?

edit:
Weil teilweise hat man schon Probleme und switch von Funktion zu Funktion weil die alle was miteinander zutun haben. Und mann muss der aller ersten Funktion_1 die Parameter übergeben die in Funktion_2 & Funktion_3 benutzt werden aber gar nicht selber in Funktion_1

Sollte man Funktionen in Funktionen aufrufen?

Ja, selbstverständlich.

Ein heutiger Rechner verkraftet schon einige Funktionsaufrufe, ich würde bei kleinen Funktionen mal schätzen an die 100.

... Macht es Sinn jeden größeren Abschnitt eines Programmes in einer Funktion zu stecken? (Manche werden nur einmal aufgerufen)...

Macht keinen Sinn, schließlich sind wir in C++, da kann man auch Klassen bauen und da Code reinpacken... (Ironie aus...)

Nee, mal im Ernst:

Es gibt ein nettes Buch "Clean Code" (Robert C. Martin), der beschreibt einen Programmierer, in dessen Programm hatte keine Funktion mehr als ca. 3 Zeilen. OK, die Java-Leute spinnen bisweilen, das halte ich für übertrieben.

Aber die Idee dahinter ist: Sobald man eine kleine, abgegrenzte Aufgabe identifizieren kann, kann man die paar Zeilen in eine Funktion stecken und diese nach dem benennen, was sie tut. Und sie sollte genau eine Aufgabe erledigen.

Den Funktionsaufruf kann man, zusammen mit anderen und anderem Code, wieder irgendwo zusammenfassen, was man passend benennen kann, nur eben eine Ebene abstrakter. Auf einmal hast du statt einer endlosten Textwüste eine nette Sammlung von high-level-Aufrufen, die das Programm kurz und knapp beschreiben, schön übersichtlich. Wie ein Inhaltsverzeichnis. Und so sollte es sich lesen: wie Prosatext.

Bis hin zu main(), das "nur" noch die Aufgaben benötigt:

int main()
{
    init();
    runApplication();
    cleanup();
}

Das Erkennen und richtige Abgrenzen von Verantwortlichkeiten und Aufgaben, das richtige Zusammenfassen, bennenen usw. ist dagegen nicht einfach und erfordert viel Übung. Aber nur zu, das ist der Weg!

Wenn du dagegen alles in main() hast, dann guten Appetit, denn dann hast du Spaghetti-Code...

der beschreibt einen Programmierer, in dessen Programm hatte keine Funktion mehr als ca. 3 Zeilen. OK, die Java-Leute spinnen bisweilen, das halte ich für übertrieben.

Kontraproduktiv triffst eher...ich zumindest hätte keine Lust so einen Code zu warten/lesen.