[Sammelthread] Codeschnippsel und kurze Fragen

[Kugelfisch23]

Wie starte ich ein Programm neue bzw. komm wieder zur einem bestimmten Anfangsteil?

while-Schleife um das ganze Programm herum?

[Grumpy_Ber]

ja hab ich auch schon überlegt aber kann man das auch auf eine anderen weise machen?

[Breed1023]

Die while-Schleife wäre aber das einfachere, eine andere weiß ich jetzt auch nicht.
Nehm while, ist meiner Meinung übersichtlicher.

[scarfish]

Da es bei Java im Gegensatz zu vielen anderen Sprachen kein Goto gibt, musste wohl ne Schleife machen. Du könntest dein Programm aber auch mehr auf Funktionen verteilen, so das die main funktion im Endeffekt nichts anderes mehr macht, als deine funktionen aufzurufen. So brauchst du bloß wieder die erste funktion aufrufen.


So, ich hätte da auch noch ne Frage zu C++. Und zwar das Makro "this" oder wie auch immer man das nennt. Was genau macht das, also worauf bezieht es sich? Bisher dachte ich immer das es einfach immer die Klasse in der es verwendet wird, repräsentiert. Aber heut bin ich auf nen QT Code gestoßen und musste feststellen, das man das wohl so Pauschal nicht sagen kann. Leider lässt sich nach "this" nur recht schwer googlen MfG scarfish

Edit: um nicht unnötig viel in den thread zu spammen schreib ichs in diesen Post:
Vielen dank @Kugelfisch, also ist es wohl doch so wie ich vermutet hatte, dann muss ich wohl bei dem Quellcode irgendwo anders ein VerständnissProblem haben.

[Kugelfisch23]

Was genau macht das, also worauf bezieht es sich? Bisher dachte ich immer das es einfach immer die Klasse in der es verwendet wird, repräsentiert.

`this` ist ein Pointer auf das Objekt, zu welchem die aktuelle Methode gehört. (Ein Objekt ist eine Instanz einer Klasse)

[yalek]

Könnte sich vielleicht jemand meine Frage von vorhin anschauen? Ich weiß, es erscheint unwichtig, aber ich verschwende viel zu Zeit damit, über solche Dinge nachzudenken. Hat einer der C++ Profis hier vielleicht einen Rat für mich?

[StarShaper]

[C++] Typdefinitionen, Konstanten und sonstiger Schmu

Hi,
ich versuche gerade, mir einen "sauberen" Programmierstil anzugewöhnen. Dabei ist mir die Frage gekommen, was wohl der beste Ort ist, um Typdefinitionen und Konstanten und sowas bekannt zu machen.
Momentan hab ich eine Datei "Include.h", die ich in jeden Header einbinde. Dort stehen Konstanten(z.B. PI), Enums und Präprozessor-Makros. Desweiteren hab ich ein Paar Klassen, mit Typdefinitionen in den Headern, z.B.

// Tokenizer.h
#include <string>
#include <vector>

typedef std::vector<std::string> StringVector;

class Tokenizer
{
   // ...
   StringVector Tokenize(const std::string&) const;
   // ...
}; 

StringVector brauche ich auch in anderen Klassen.
Die Frage ist jetzt: Ist es besser, StringVector in Include.h zu definieren und damit implizit überall <string> und <vector> einzubinden, oder überall, wo ich StringVector brauche auch Tokenizer.h einzubinden, obwohl der Tokenizer dort gar nicht gebraucht wird?

Das Schlüsselwort typedef dient primär dazu die Lesbarkeit eines Programms zu verbessern, vor allem wenn komplexe Datentypen einen Namen erhalten. Beispiel:

 #include <memory>
 
 class Base {
 public:
   ...
   typedef std::auto_ptr<Base> Ptr;  // typedefs simplify the code
   static Ptr create();
   ...
 };
 
 Base::Ptr Base::create()
 {
   Ptr p(/*...use a factory to create a Derived object via new...*/);
   p->init();
   return p;
 } 

Darüberhinaus besteht ein weiterer Vorzug darin, das maschinenabhängige Typen isoliert werden können. Bei der Portierung eines Programms auf einen anderen Rechner (Compiler) muss der maschinenabhängige Datentyp nur einmal in der typedef-Definition geändert werden. Beispiel:

#if (defined(_MSC_VER) && (!defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1000) && (defined(_M_X64) || defined(_M_IA64))) || (defined(__DECCXX) && defined(__alpha__)) || (defined(__INTEL_COMPILER) && defined(__x86_64__))
    typedef word32 hword;
    typedef word64 word;
#else
    #define CRYPTOPP_NATIVE_DWORD_AVAILABLE
    #if defined(__alpha__) || defined(__ia64__) || defined(_ARCH_PPC64) || defined(__x86_64__) || defined(__mips64) || defined(__sparc64__)
        #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
            typedef word32 hword;
            typedef word64 word;
            typedef __uint128_t dword;
            typedef __uint128_t word128;
            #define CRYPTOPP_WORD128_AVAILABLE
        #else
            // if we're here, it means we're on a 64-bit CPU but we don't have a way to obtain 128-bit multiplication results
            typedef word16 hword;
            typedef word32 word;
            typedef word64 dword;
        #endif
    #elif defined(WORD64_AVAILABLE)
        #define CRYPTOPP_SLOW_WORD64 // use alternative code that avoids word64
        typedef word16 hword;
        typedef word32 word;
        typedef word64 dword;
    #else
        typedef byte hword;
        typedef word16 word;
        typedef word32 dword;
    #endif
#endif 

Derartige typedef-Definitionen gehören in der Tat in eine seperate Header-Datei. Du solltest dir die Frage stellen ob ein typedef namens StringVector für std::vector<std::string> Sinn macht? Das Schlüsselwort typedef ist nämlich keineswegs dafür gedacht allen möglichen Standardtypen einen neuen Namen zu verpassen.

In jedem Fall gehört die typedef-Definition in eine seperate Header (global namespace), falls du diese global in vielen Dateien einsetzen möchtest. Diese kannst du config.h oder mytypes.h nennen.

cu

[yalek]

Vielen Dank für die Antwort!

Dann werde ich meine Typedefs jetzt in einen seperaten Header tun und den bei Bedarf einbinden.

Ich denke schon, dass ein Typedef für std::vector<std::string> Sinn macht, weil StringVector viel leichter zu lesen(und zu schreiben) ist und ich bei Bedarf auch eine std::list<std::string> oder sonstwas statt des std::vector<std::string> nehmen kann(solange das Interface gleich bleibt). Ein allgemeinerer Name wie StringList wäre vielleicht besser.

[StarShaper]

Ich denke schon, dass ein Typedef für std::vector<std::string> Sinn macht, weil StringVector viel leichter zu lesen(und zu schreiben) ist und ich bei Bedarf auch eine std::list<std::string> oder sonstwas statt des std::vector<std::string> nehmen kann(solange das Interface gleich bleibt). Ein allgemeinerer Name wie StringList wäre vielleicht besser.

Mein Hinweis sollte auch nur allgemeiner Natur sein, typedef-Definitionen überlegt einzusetzen. Weitere Antworten dazu hast du dir in den nachfolgenden Sätzen selbst geliefert.

cu

[yalek]

Ah, ok, dann ist jetzt alles klar.
Danke nochmal.

[hav]

edit: hat sich erledigt

[kide]

Hier sind einige meiner Delphisnippets, falls jemand etwas damit anfangen kann.

Vor allem Interessant könne "Sort.pas" sein, da oft Fragen zu Sortieralgorithmen gestellt werden.

[Schmeisser]

Hallo ihr,
ich brauche Hilfe. Es geht um Turbo Pascal. Ich will fogendes Program schreiben.

Man wird Anfangs gefragt, wie viele "*" man haben will. Danach wird man nach der Wunschposition gefragt. Also der User soll eingeben ob Senkrecht oder Waagerecht und je nach Antwort erscheinen die "*" halt nebeneinander oder untereinander. Ich bekomme das einfach nicht gebacken!

Program Beispiel;
uses crt;
var a, b, c, endwert;

begin
clrscr;
write('Wie viele * sollen geschrieben werden? ');
readln(endwert);
write('In welcher Position sollen die * geschrieben werden? ');
readln(b);
case b of
'senkrecht': {keine Ahnung -.-}
'waagerecht': 
For c:= 1 to endwert do
write('*');
else 
write('Diese Position ist nicht auswählbar!');
end;
readln;
end.

Leider scheitert es schon an den beiden Worten "Senkrecht" und "Waagerecht". Bei "Case of" darf man ja nur Zahlen verwenden.

MfG.

[PimmelJoe_]

moin moin
ich hab auch mal ne frage
ich muss eine facharbeit über bezierkurven schrieben und dazu ein programm mit java schrieben.
und jetzt wollte ich mal wissen ob sich hier jemand auskennt und mir vllt helfen könnte ?
thx

[maxro]

@ Schmeisser

hmm ich kenn mich zwar überhaupt nicht aus aber versuchs mal so :

senkrecht = 'senkrecht';

case b of
senkrecht : // mach was auch immr

und das hier habe ich über goggel gefunden:

Spoiler: 

Bei der Case-Of-Anweisung gilt folgendes zu beachten :
# die Case-Of-Anweisung wählt immer nur eine von beliebig vielen Alternativen aus
# vor jeder Anweisung stehen eine oder mehrere durch Komma getrennte Konstanten, gefolgt von einem Doppelpunkt
# Variable und Konstante müssen vom selben Typ sein
(Sie können keiner Integer-Variable eine Dezimalzahl zuweisen !!)
# sind die Konstanten char-Werte, so sind sie in Hochkomma zu setzen
# sollen nach dem Doppelpunkt mehrere Anweisungen folgen, so sind diese in einer Verbundanweisung zusammenzufassen
(Der Anweisungskomplex,welcher ausgeführt werden soll, wird von Begin und End; umschlossen.)
# die Case-Of-Anweisung endet mit dem Wort End, gefolgt von einem Semikolion

[M3þh!$tø]

Ich hätte ebenfalls ne Frage, und da ja hier recht kompetente Leute unterwegs sind

Es geht um C++.

Ich möchte eine Zahl einlesen und diese dann in ihre einzelnen Stellen unterteilen, welche ich dann jeweils gleich weiterverarbeite.

Klappt soweit ganz gut, habs mit modula gemacht, jedoch gibt es ein Problem das ich nicht lösen kann:

Gibt man z.B. 1001 ein bekomme ich keine 1000er Stelle als Ausgabe, dafür aber bei der 100 Stelle eine 10 als Antwort. Weiß jemand wie man das korrigieren könnte?

Hier der Code:

Spoiler: 

cout<<"Zahl eingeben:" << endl;
cin >> k;
unsigned long long x = k;

while(x > 10)
{
x = x/10;
zaehler2*=10;
}

while(zaehler2 > 0)
{
stelle = (k-(k%zaehler2))/zaehler2;

cout << zaehler2 << "er Stelle: " << stelle << endl;

k = k - zaehler2*stelle;
zaehler2 = zaehler2 / 10;
}

Danke für jede hilfreiche Antwort

[Uzaku]

Hi ich würde es mal so versuchen (ungetestet)

char zahl[10] = {""};
int i = 0, k=0, stellen[10] ;

memset(stellen, 0, sizeof stellen);

cin >> zahl 

for(i=10, k=0; i>10 ;i--, k++){
  if(zahl[i]){
     stellen[k] = zahl[i] - '0';
  }
} 

Dann hast du in stellen[0] die Einzerstelle, in stellen[1] die Zehnerstelle u.s.w.
Wenn ich mit diesem Code jemanden geärgert haben sollte (weil er eine Mischung aus C und C++ ist oder weil er unelegant ist, so tut es mir leid, und ich bitte um Entschuldigung)

[M3þh!$tø]

Problem hierbei ist, dass ich nicht weiß wie groß die Zahlen werden.

Und da dynamische Speicherverwaltung bei Feldern nicht sooo meine Stärke ist, würd ich doch eher einen Code der in meine Richtung geht bevorzugen.

Aber trotzdem Danke.

[insa]

Es ist relativ einfach, wenn du weißt wie groß die Zahl ist. Ich würde das folgendermaßen machen:

#include <iostream>
#include <string>
using namespace std;

int main() {
	string foo;
	cin >> foo;
	cout << "foo ist " << foo.length() << " Zeichen lang!" << endl;
	
	for (int i = 0; i < foo.length(); i++)
		cout << foo[i] << endl; //gibt eine Stelle der Zahl nach der anderen aus
	
	cin.ignore();
	cin.get();
 return 0;
}

Ich hoffe das hilft dir weiter

[M3þh!$tø]

Ah, Dankeschön!
Genau das was ich wollte. Ich bin da wohl etwas zu kompliziert vorgegangen, jetzt wo ich das seh