fb18.de
/ Diplom Informatik
/ Unterbereich Grundstudium
/ Praktische Informatik
Eingabe-Dilemma in C++
Plz watch out my source-code:
#include<iostream>
using namespace std;
int main() {
int n = 0;
char ch;
cout<<"The unbreakable Quicksortalgorithm, or so..";
cout<<"\n Please insert your favoured size of your dreamarray ";
if(!(cin>>n))
{
cout<<"Eingabefehlerchen";
return 0;
}
if(n>0)
{
char sortarray[n];
for(int a=0; a<=n; a++)
{
cout<<"e";
cin.get(ch);
if (ch != '#')
{ sortarray[a] = ch;}
}
}
}
die Ausgabe "e" habe ich testweise eingefügt - das problem, er läuft die Schleife zu oft ab, d.h. es tauchen zwei es' auf bevor man eine eingabe machen kann, ich hab auch schon das gleiche mit do-schleife probiert, kann aber nicht meinen fehler erkennen…
kann da jemand helfen?
Kann es sein, dass du am Anfang vielleicht eine zweistellige Zahl eingibst?
Möglicherweise liest er dann nur die erste Ziffer und sieht die zweite Ziffer gleich schon als Eingabe im ersten Schleifendurchlauf.
Oder tritt das auch auf, wenn du eine einstellige Zahl eingibst?
Kann es sein, dass du am Anfang vielleicht eine zweistellige Zahl eingibst?
Möglicherweise liest er dann nur die erste Ziffer und sieht die zweite Ziffer gleich schon als Eingabe im ersten Schleifendurchlauf.
Oder tritt das auch auf, wenn du eine einstellige Zahl eingibst?
ja, auch wenn ich eine einstelige ziffer eingebe gibt er zwei nal e aus..
Plz watch out my source-code:
PLZ? Postleitzahl? Was hat das damit zu tun?
#include<iostream>
using namespace std;
"using namespace" gehört verboten, da Du gar nicht wissen kannst, welche Namen damit vordefiniert sind und was das für Auswirkungen hat. Nimm lieber "using std::cout; using std::cin;".
int main() {
int n = 0;
char ch;
cout<<"The unbreakable Quicksortalgorithm, or so..";
cout<<"\n Please insert your favoured size of your dreamarray ";
if(!(cin>>n))
{
cout<<"Eingabefehlerchen";
return 0;
}
if(n>0)
{
char sortarray[n];
for(int a=0; a<=n; a++)
"a < n" statt "a <= n".
{
cout<<"e";
cin.get(ch);
if (ch != '#')
{ sortarray[a] = ch;}
}
}
}
Du erhöhst
a in jedem Fall, auch wenn Du gar kein Zeichen an der Position gespeichert hast. Das sieht nicht gut aus.
die Ausgabe "e" habe ich testweise eingefügt - das problem, er läuft die Schleife zu oft ab, d.h. es tauchen zwei es' auf bevor man eine eingabe machen kann, ich hab auch schon das gleiche mit do-schleife probiert, kann aber nicht meinen fehler erkennen…
kann da jemand helfen?
Gib doch mal statt "e" den Zeichencode des gerade eingelesenen Zeichens aus. Vielleicht ist das aufschlußreicher.
Roland
Mit Änderungen:
#include<iostream>
//using namespace std;
using std::cout;
using std::cin;
int main() {
int n = 0;
char ch;
cout <<"The..";
cout<<"\n Please insertsize ";
if(!(cin>>n))
{
cout<<"Eingabefehlerchen";
return 0;
}
if(n>0)
{
char sortarray[n];
for(int a=0; a<n;a++)
{
//cout<<"e";
cin.get(ch);
cout<<ch;
if (ch != '#')
{ sortarray[a] = ch;}
}
}
}
Plz :=please (slang-abkürzung)
ach ja wenn ich jetzt 5 als size eingebe kann ich zwei chars eingeben
beispiel:
eingabe: b
ausgabe: b
eingabe: c
ausgabe: c
immer noch kA warum…
Wenn man das Programm nochmal etwas erweitert, so dass der Zeichencode ausgegeben wird (also etwa cout << (int)ch;) sieht man:
cout << ch;
frisst jeweils genau ein Zeichen. Die Eingaberoutine beendet sich aber erst nach einem abschließenden Zeilenumbruch. Und das ist auch ein Zeichen. Ein ähnliches Problem bekommst du bei dem Eingeben der Anzahl, da nimmt man ne Zahl und die ist auch vorbei, wenn der Zeilenumbruch kommt. Der Zeilenumbruch bleibt erstmal hängen und wird erst später bei "cin << ch" eingelesen. Wenn du also eingibst:
5
b
c
Empfängt dein C-Programm:
5bc
und das ist einmal die 5 für die Eingabe und danach 5 Zeichen.
Wenn man das Programm nochmal etwas erweitert, so dass der Zeichencode ausgegeben wird (also etwa cout << (int)ch;) sieht man:
cout << ch;
frisst jeweils genau ein Zeichen. Die Eingaberoutine beendet sich aber erst nach einem abschließenden Zeilenumbruch. Und das ist auch ein Zeichen. Ein ähnliches Problem bekommst du bei dem Eingeben der Anzahl, da nimmt man ne Zahl und die ist auch vorbei, wenn der Zeilenumbruch kommt. Der Zeilenumbruch bleibt erstmal hängen und wird erst später bei "cin << ch" eingelesen. Wenn du also eingibst:
5
b
c
Empfängt dein C-Programm:
5<Zeilenumbruch>b<Zeilenumbruch>c<Zeilenumbruch>
und das ist einmal die 5 für die Eingabe und danach 5 Zeichen.
so ganz vertseh ich dich nicht - wenn ich das:
cout << (int)ch; vor die zeichenausgabe
cout<<ch; anhänge, bekomme ich auch immer die zahl 10 am Ende ausgegeben, auch wenn ich die size eingebe, ist das die zeilenumbruchanweisung ?
Warum liest er die so ein?
Was kann man dagegen tun?
Ja, die 10 entspricht dem Zeilenumbruch. Das liest er ein, weil du nen Zeilenumbruch eingegeben hast [img]
http://www.fb18.de/gfx/28.gif[/img]
Was man dagegen tun kann? Im einfachsten Fall den wert von ch darauf prüfen und das als illegale eingabe annehmen. Gibt sicherlich noch bessere Möglichkeiten, direkt cin zu sagen, dass er sowas lassen soll, aber ich kenne mich mit C++-Streams nicht gut genug aus dafür.
ich hab jetzt nur ein dreckiges workarround gemacht:
if (int(ch)==10){cin.get(ch);}
mir fällt jetzt nichts besseres ein (Zeitdruck [img]
http://www.fb18.de/gfx/19.gif[/img] )
weiss jdm was besseres?
interessant mit cin also nicht cin.get(ch) treten solche Probleme nicht auf..
verdammt hab jetzt hier quicksort mit arrays realisiert und seh jetzt das man in C++ irgendwie nicht die Size/length von arrays wie in java rausbekomme - was würdet ihr mir jetzt empfehlen um dieses Malheur in kurzer Zeit zu umschiffen…
hier der quicksort der lustigerweise nicht funktioniert [img]
http://www.fb18.de/gfx/26.gif[/img] :
#include<iostream>
#include<cctype>
#include<cstdlib>
#include<vector>
//using namespace std;
using std::cout;
using std::cin;
void QuickSort(vector<char> eingabearray);
void RekQuickSort(vector<char> eingabearray , int Low, int High);
void Swap(vector<char> eingabearray, int a, int k);
int main() {
int n = 0;
char ch;
vector<char> sortarray;
cout <<"quicksort_it";
cout<<"\n Please insert your favoured size of your dreamarray ";
if(!(cin>>n))
{
cout<<"Eingabefehler";
return 0;
}//else if (int(ch)==10){cin.get(ch);}
if(n>0)
{
vector<char> sortarray(n);
for(int a=0; a<n;a++)
{
//cout<<"e";
cin>>ch;
if (!isalpha(ch))
{cout<<"Bullshit";
cin>>ch;}
if (ch != '#')
{ if (isalpha(ch))
{
sortarray[a] = ch;
}
}
}
for(int a=0; a<n;a++)
{cout<<sortarray[a];}
system("Pause");
QuickSort(sortarray);
for(int a=0; a<n;a++)
{
cout << sortarray[a];
}
system("Pause");
}
}
void RekQuickSort(vector<char> eingabearray, int Low, int High){
//char[] eingabearray
int links = Low;
int rechts = High;
int mitte = (links+rechts)/2;
if (eingabearray[links] > eingabearray[mitte]) Swap(eingabearray, links, mitte);
if (eingabearray[mitte] > eingabearray[rechts]) Swap(eingabearray, mitte, rechts);
if (eingabearray[links] > eingabearray[mitte]) Swap(eingabearray, links, mitte);
if((rechts-links)>2){
char pivot = (char)eingabearray[mitte];
do{
while(eingabearray[links] < pivot) links++;
while(pivot < eingabearray[rechts]) rechts++;
if(links <= rechts){Swap(eingabearray, links, rechts); links++; rechts++;}
}while(links <= rechts);
if(Low < High)RekQuickSort(eingabearray, Low, rechts);
if(links < High)RekQuickSort(eingabearray, links, High);
}
}
void QuickSort(vector<char> eingabearray){
int High = eingabearray.size()-1;
RekQuickSort(eingabearray, 0, High);
}
void Swap(vector<char> eingabearray, int a, int k){
char h = eingabearray[a];
eingabearray[a] = eingabearray[k];
eingabearray[k] = h;
}
Was kann ich falsch gemacht haben?
bin total vezweifelt…
verdammt hab jetzt hier quicksort mit arrays realisiert und seh jetzt das man in C++ irgendwie nicht die Size/length von arrays wie in java rausbekomme - was würdet ihr mir jetzt empfehlen um dieses Malheur in kurzer Zeit zu umschiffen…
In C++ gibt es std::vector
verdammt hab jetzt hier quicksort mit arrays realisiert und seh jetzt das man in C++ irgendwie nicht die Size/length von arrays wie in java rausbekomme - was würdet ihr mir jetzt empfehlen um dieses Malheur in kurzer Zeit zu umschiffen…
In C++ gibt es std::vector
ist ja schon oben mit vectoren geschrieben [img]
http://www.fb18.de/gfx/26.gif[/img]
verdammt hab jetzt hier quicksort mit arrays realisiert und seh jetzt das man in C++ irgendwie nicht die Size/length von arrays wie in java rausbekomme - was würdet ihr mir jetzt empfehlen um dieses Malheur in kurzer Zeit zu umschiffen…
In C++ gibt es std::vector
ist ja schon oben mit vectoren geschrieben [img]http://www.fb18.de/gfx/26.gif[/img]
klappt aber trotzdem nicht
ok
die zeile
if(Low < High)RekQuickSort(eingabearray, Low, High) ...;
in
void RekQuickSort(vector<char> eingabearray, int Low, int High){
//char[] eingabearray
int links = Low;
int rechts = High;
int mitte = (links+rechts)/2;
if (eingabearray[links] > eingabearray[mitte]) Swap(eingabearray, links, mitte);
if (eingabearray[mitte] > eingabearray[rechts]) Swap(eingabearray, mitte, rechts);
if (eingabearray[links] > eingabearray[mitte]) Swap(eingabearray, links, mitte);
if((rechts-links)>2){
char pivot = (char)eingabearray[mitte];
do{
while(eingabearray[links] < pivot) links++;
while(pivot < eingabearray[rechts]) rechts++;
if(links <= rechts){Swap(eingabearray, links, rechts); links++; rechts++;}
}while(links <= rechts);
if(Low < High)RekQuickSort(eingabearray, Low, High);
if(links < High)RekQuickSort(eingabearray, links, High);
}
}also 2. von unten war nat. falsch, hier richtig:
if(Low < High)RekQuickSort(eingabearray, Low, [b]rechts[/b]);
scheint aber noch immer nicht richtig zu sein - krieg jetzt keine ausgabe
noch die zeile:
while(pivot < eingabearray[rechts]) rechts++;
->
while(pivot < eingabearray[rechts]) rechts--;
aber immer noch nicht richtig.. [img]
http://www.fb18.de/gfx/21.gif[/img]
new version
#include<iostream>
#include<cctype>
#include<cstdlib>
#include<vector>
//using namespace std;
using std::cout;
using std::cin;
void QuickSort(vector<char> eingabearray);
void RekQuickSort(vector<char> eingabearray , int Low, int High);
void Swap(vector<char> eingabearray, int a, int k);
int main() {
int n = 0;
char ch;
vector<char> sortarray;
cout <<"quicksort it";
cout<<"\n Please insert your favoured size of your dreamarray ";
if(!(cin>>n))
{
cout<<"Eingabefehler";
return 0;
}//else if (int(ch)==10){cin.get(ch);}
if(n>0)
{
vector<char> sortarray(n);
for(int a=0; a<n;a++)
{
//cout<<"e";
cin>>ch;
if (!isalpha(ch))
{cout<<"Bullshit";
cin>>ch;}
//if (int(ch)==10){cin.get(ch);}
//cout<<int(ch);
//cout<<ch;
if (ch != '#')
{ if (isalpha(ch))
{
sortarray[a] = ch;
}
}
}
for(int a=0; a<n;a++)
{cout<<sortarray[a];}
system("Pause");
QuickSort(sortarray);
for(int a=0; a<n;a++)
{
cout << sortarray[a];
}
system("Pause");
}
}
void RekQuickSort(vector<char> eingabearray, int Low, int High){
//char[] eingabearray
int links = Low;
int rechts = High;
int mitte = (links+rechts)/2;
if (eingabearray[links] > eingabearray[mitte]) Swap(eingabearray, links, mitte);
if (eingabearray[mitte] > eingabearray[rechts]) Swap(eingabearray, mitte, rechts);
if (eingabearray[links] > eingabearray[mitte]) Swap(eingabearray, links, mitte);
if((rechts-links)>2){
char pivot = (char)eingabearray[mitte];
do{
while(eingabearray[links] < pivot) links++;
while(pivot < eingabearray[rechts]) rechts--;
if(links <= rechts){Swap(eingabearray, links, rechts); links++; rechts--;}
}while(links <= rechts);
if(Low < rechts)RekQuickSort(eingabearray, Low, rechts);
if(links < High)RekQuickSort(eingabearray, links, High);
}
}
void QuickSort(vector<char> eingabearray){
int High = eingabearray.size()-1;
RekQuickSort(eingabearray, 0, High);
}
void Swap(vector<char> eingabearray, int a, int k){
char h = eingabearray[a];
eingabearray[a] = eingabearray[k];
eingabearray[k] = h;
}
still not running [img]
http://www.fb18.de/gfx/11.gif[/img]
Gib doch mal die Werte links, rechts, mitte in RekQuickSort auf dem Bildschirm aus. Vielleicht merkst Du ja dann etwas.
Gib doch mal die Werte links, rechts, mitte in RekQuickSort auf dem Bildschirm aus. Vielleicht merkst Du ja dann etwas.
die änderungen:
void RekQuickSort(vector<char> eingabearray, int Low, int High){
//char[] eingabearray
int links = Low;
cout<<links;
int rechts = High;
cout<<rechts;
int mitte = (links+rechts)/2;
cout<<mitte;
if (eingabearray[links] > eingabearray[mitte]) Swap(eingabearray, links, mitte);
if (eingabearray[mitte] > eingabearray[rechts]) Swap(eingabearray, mitte, rechts);
if (eingabearray[links] > eingabearray[mitte]) Swap(eingabearray, links, mitte);
if((rechts-links)>2){
char pivot = (char)eingabearray[mitte];
do{
while(eingabearray[links] < pivot) links++;
while(pivot < eingabearray[rechts]) rechts--;
if(links <= rechts){Swap(eingabearray, links, rechts); links++; rechts--;}
cout<<links;
cout<<rechts;
cout<<mitte;
}while(links <= rechts);
if(Low < rechts)RekQuickSort(eingabearray, Low, rechts);
if(links < High)RekQuickSort(eingabearray, links, High);
}
}
Bei einer Eingabe von size=5,
d g q a d bgibt er aus 0421121-22142212243 und immer noch
d g q a d b-> Das ergibt doch keinen Sinn, wenn ich den Weg so nachverfolge müsste er doch RekQuickSort(eingabearray, 0, 1) und eingabearray(eingabearray, 1, 4) aufrufen aber da kann doch nicht so eine Ausgabe folgen - ich verstehs nur bis
042112
Das kann so auch gar nicht funktionieren, du übergibts den std::vector auch "by-value" und nicht "by-reference".
void RekQuickSort(vector<char> eingabearray, int Low, int High) ->
void RekQuickSort(vector<char> & eingabearray, int Low, int High)
void QuickSort(vector<char> eingabearray) ->
void QuickSort(vector<char> & eingabearray)
Statt deiner swap-Funktion kannst du std::swap benutzen, einfach den header <algorithm> includen.
Das kann so auch gar nicht funktionieren, du übergibts den std::vector auch "by-value" und nicht "by-reference".
void RekQuickSort(vector<char> eingabearray, int Low, int High) ->
void RekQuickSort(vector<char> & eingabearray, int Low, int High)
void QuickSort(vector<char> eingabearray) ->
void QuickSort(vector<char> & eingabearray)
Statt deiner swap-Funktion kannst du std::swap benutzen, einfach den header <algorithm> includen.
ob dus glaubst oder nicht - habs ca. ne sekunde vorher herausgefunden bevor ich dein posting gelesen hab (beim lesen alter aufgaben) -> ich könnte mich ohrfeigen…
..immer wieder diese s******* referenzen…
trotzdem danke (auch an fred)
Tss, tss, tss. Einfach so stillschweigend den Rückgabewert von printf ignorieren. Das würde ich als Lehrerin auch nicht durchgehen lassen. [img]
http://www.fb18.de/gfx/24.gif[/img]
LEIFer
Und was genau soll er mit dem Ausgabewert, der aufgrund der Programmstruktur ja offensichtlich konstant ist, tun?
Mo
Tss, tss, tss. Einfach so stillschweigend den Rückgabewert von printf ignorieren. Das würde ich als Lehrerin auch nicht durchgehen lassen. [img]http://www.fb18.de/gfx/24.gif[/img]
LEIFer
Viel schlimmer ist die unkonventionelle Benutzung der
for-Schleife. In C fängt sowas generell mit 0 an, es sei denn, es gibt gute Gründe dagegen. Denn im Fall
INT_MAX == 500 mit Wraparound würde dieser Code zu einer Endlosschleife führen.
Deshalb sollte man die Abbruchbedingung lieber mit
< als mit
<= schreiben.
Und was genau soll er mit dem Ausgabewert, der aufgrund der Programmstruktur ja offensichtlich konstant ist, tun?
Meinst Du das "return 0"?
ISO C99, 6.9.1#12:
If the "}" that terminates a function in reached, and the value of the function call is used by the caller, the behavior is undefined.
Da Du im allgemeinen nicht wissen kannst, ob die Umgebung den Rückgabewert verwendet, solltest Du ihn explizit angeben. In POSIX-Systemen wird er garantiert verwendet, also mußt Du ihn angeben.
Roland
Außerdem fehlt das "\n" in dem String.
Denn im Fall INT_MAX == 500 mit Wraparound würde dieser Code zu einer Endlosschleife führen.
Bitte zeige mir eine Architektur mit einem geraden INT_MAX.
Denn im Fall INT_MAX == 500 mit Wraparound würde dieser Code zu einer Endlosschleife führen.
Bitte zeige mir eine Architektur mit einem geraden INT_MAX.
Ein Ternär-Rechner mit 7
Trits pro char? Den hab ich zwar noch nicht in der Realität gesehen, aber denkbar ist sowas. Wenn man dann noch
sizeof(int) == 3 annimmt, ist
INT_MAX == 3^21 - 1, und das ist gerade. :)
Und was genau soll er mit dem Ausgabewert, der aufgrund der Programmstruktur ja offensichtlich konstant ist, tun?
Meinst Du das "return 0"?
Roland
Nein, LEIF sprach davon, dass der Junge (Ich kann mir die verdammten Namen nciht merken. Dabei gehoert FoxTrot zu den ganz grossen ;) ) den printf Rueckgabewert nicht ueberprueft hat.
Mo
Und was genau soll er mit dem Ausgabewert, der aufgrund der Programmstruktur ja offensichtlich konstant ist, tun?
Falls es bei der Ausführung von printf zu einem Fehler kommt, gibt es einen anderen Rückgabewert. Wie? printf schlägt nie fehl? Dann sollte man diese Annahme mit (void) explizit machen.
Aber vielleicht ist diese Annahme über die Laufzeitumgebung auch falsch? Da der Platz auf einer Tafel nun einmal begrenzt ist und möglicherweise kein Scrollen oder Überschreiben implementiert ist, könnte dort ein Fehler durchaus auftreten.
Außerdem fehlt das "\n" in dem String.
Nö, wie uns Bart lehrt, schreibt man auf einer Tafel fortlaufend. Ein Leerzeichen nach dem Punkt würde allerdings die Ausgabe lesbarer machen.
[img]
http://justfuckinggoogleit.com/bart.gif[/img]
LE;-)IFer
Der Rückgabewert von printf ist AFAIK die Anzahl ausgegebener Zeichen und kein Fehlercode.
Der Rückgabewert von printf ist AFAIK die Anzahl ausgegebener Zeichen und kein Fehlercode.
Die manpage sagt:
Upon successful return, these functions return the number of characters printed (not including the trailing '\0' used to end output to strings). […] If an output error is encountered, a negative value is returned.
LEIFer
OK. Aber Fehlerbehandlung über Rückgabewerte finde ich sowieso doof [img]
http://www.fb18.de/gfx/24.gif[/img]
Naja… Haare lassen sich ja bekanntlich beliebig oft spalten. (Anders als andere Gequantelte raeumliche Koerper).
Und LEIFer… Die (void) Notation ist echt n bisschen uebertrieben, findest Du nicht auch? Da moechte ich Dich doch glatt fragen, ob Du Deine Fallthroughs auch immer brav mit
//fallthrough
oder natuerlich, wenn man reines C lieber mag: /* fallthrough */
markierst :)
Mo
Nein, ich programmier so nicht. Schließlich programmiere ich ja auch kein C. [img]
http://www.fb18.de/gfx/24.gif[/img]
Ich kann Fred nur zustimmen: Fehlerbehandlung über Rückgabewerte ist sowieso doof.
Hmhm… Aber in C++ bzw Java funktionierts ja genauso… Wie machst Du das da?
Mo
Wie jetzt? In C++ und Java gibt es Exceptions. Und printf gibt's da nicht.
Aber bevor Ihr jetzt weiter darüber diskutiert möchte ich erst mal einen Compiler sehen, welcher ein mit Kreide an die Tafel geschriebenes C-Programm in ausführbaren Code übersetzt. Macht das dann ein anderer Schüler? Welcher wiederum einen dritten instruiert? [img]
http://www.fb18.de/gfx/23.gif[/img]
Außerdem ist ++count generell count++ vorzuziehen
(es sei denn, man braucht es wirklich).
Wie jetzt? In C++ und Java gibt es Exceptions. Und printf gibt's da nicht.
Ich meinte (void) und fallthroughs.
Mo
Wie jetzt? In C++ und Java gibt es Exceptions. Und printf gibt's da nicht.
Insbesondere ist Java kein C. Es ist eine andere Sprache, mit einer anderen Kultur. Die andere Kultur bedeutet unter anderem auch andere Vorgehensweisen und andere typische Fehler.
(void)
Soweit ich weiß, ist das in der Javasyntax schon aus zwei Gründen gar nicht möglich: Zum ist kein Cast of void erlaubt, zum anderen kann man das Ergebnis einer Anweisung nicht casten, sondern nur in Ausdrücken.
Tatsächlich werden in Java ja Rückgabewerte von Methoden wesentlich weniger dafür verwendet, um Fehler anzuzeigen. Das läuft meht über Ausnahmen. Rückgabewerte sind meistens die Ergebnisse von Funktionen oder aber ein Objekt gibt sich selber am Ende einer Prozedur zurück, um eine Verkettung von Aufrufen zu ermöglichen, wie z.B. foo.append("bar").append(98).
fallthroughs
Treten bei mir extrem selten auf. Keine Ahnung, ob man bei Java 5 - welches ich noch kaum verwende - mit Enums wieder mehr zu switch-Strukturen kommt, in Prä-5 setze ich generell switch sehr selten ein: Oft ziehe ich Polymorphie vor. Für switch müßte ich auch ein int oder artverwandes in der Hand haben, meist arbeite ich aber lieber mit richtigen Objekten. Hierfür war das Java-switch lange zu schwachbrüstig.
Ich glaube, Java 5 gibt bei fallthroughs auch tatsächlich eine Warnung aus.
(Dafür verwendet der Typ mit seinem C code eine vernünftige Anzahl an Newlines, im Gegensatz zu den ursprünglichen Quellcodes hier…)
Und printf gibt's da nicht.
System.out.printf gibt es sehr wohl.
Außerdem gibt es auch noch
java.util.Formatter.
Laut Java-Dokumentation: "An interpreter for printf-style format strings".
Außerdem ist ++count generell count++ vorzuziehen
(es sei denn, man braucht es wirklich).
Warum eigentlich nicht count+1?
count+1 verändert den Wert von count nicht.
count+1 verändert den Wert von count nicht.
Warum, der ist um eins hoeher?
count+1 ist ein Ausdruck, dessen Wert um 1 höher ist als der Wert von count. Im Gegensatz zu count++ hat dieser Ausdruck aber keinerlei Seiteneffekte; count bleibt unberührt. Nimm doch mal folgenden Codeabschnitt als Beispiel:
int x = 5;
int y = x+1;
Erwartest Du jetzt, dass x 5 ist oder 6?
