[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]

Zitat von yalek

[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.

PHP-Code:

// 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:

PHP-Code:

 #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:

PHP-Code:

#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]

Zitat von yalek

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.

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)

PHP-Code:

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

[kide]

Zitat von 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.

Warum denn unbedingt mit case und nicht mit if? bei 3 möglichen Werten ist das doch genausowenig Schreibaufwand.

PHP-Code:

if b="senkrecht" then setzesenkrecht else if b="waagerecht" then setzewaagerecht; 


[M3þh!$tø]

Ist es möglich aus Zahlen, Dualzahlen zu errechnen die keine feste Größen-Grenze haben wie bei folgendem Code, da werden halt nur 64 Bit dargestellt wegen der Größe von String. Ich will dann halt einfach die ganze Binärzahl ausgeben als Folge von 1en und 0en. Vielleicht ist das irgendwie rekursiv lösbar?

Spoiler:

PHP-Code:

string ausgabe;

while (zahl!=0)
{
    ausgabe.insert(0,1,'0'+(char)(zahl % 2));
         zahl /= 2;
}

cout << ausgabe << endl; 


Also sagen wir mal halt z.B von der Zahl 4265765517992072256 z.B. die Dualzahl.

In C/C++.


Danke schon mal.

[SoulSpirit]

Zitat von M3þh!$tø

... da werden halt nur 64 Bit dargestellt wegen der Größe von String.

hä?? Willst du damit sagen dass ein String in C++ nur 64 Zeichen lang sein kann? Das wäre mir doch sehr neu...

[Kugelfisch23]

Zitat von M3þh!$tø

Vielleicht ist das irgendwie rekursiv lösbar?

Rekursiv ist in diesem Falle schlecht, da wirst du bei grossen Zahlen irgendwann an das Grössenlimit des Stacks anstossen...

[M3þh!$tø]

Jetz hab ich sicherheitshalber nochmal nachgeschaut und du hast recht, es ist nicht auf 64 Zeichen beschränkt.

Aber bei meinem Code werden trotzdem nur 64 einsen und nullen ausgegeben, obwohl ich weiß, dass die Zahl mehr hat (hab halt zuerst ne Folge von 1 und 0 int ne Zahl umgewandelt und wollte diese anschließend zum testen zurückwandeln).

Weiß einer warum?

[J-Fox]

0x3B330B233B071440 = 4265765517992072256

speicherst du das in einem double?

Zudem:

PHP-Code:

Double (0xFFFFFFFFFFFFFFFF):
11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111
Dein wert:
00111011 00110011 00001011 00100011 00111011 00000111 00010100 01000000
Segmente:
1        2        3        4        5        6        7        8
12345678 


Sind 8 segmente, 8 Bit pro segment = 64 Bit, die vorderen 2 Bit werden nicht genutzt, also sind es sogar nur 62 Bit...

Wenn das problem wie du bereits erwähnt hast auch bei anderen werten auftritt hängt das sehr wahrscheinlich mit dem datentyp zusammen, wie du sehen kannst passen in ein double auch "nur" 64 Bit (2*32 Bit = 8 Byte)

[M3þh!$tø]

Ok, mit der Zahl gehts jetzt.

Aber nehmen wir an, ich habe folgende Binärzahl:

000011001000110010101100010011000101000000001100100111001001110011101100110 01100001011001000110011101100000111000101000011111111

in Dezimal, wenn ich es umwandel:

17063062071968289023

wenn ichs dann wieder zurückwandel(mit dem Code von oben):

111011001100110000101100100011001110110000011100010100001111110

also 8531531035984144510


Was stimmt hier nicht?

PS: Der Wert ist in einem unsigned long long gespeichert.

[J-Fox]

In dem fall hast du meinen post denn nicht verstanden, lass dir mal sizeof(unsigned long long) ausgeben... ich könnte schwören (ohne den datentyp voher so bewusst genutzt zu haben) es wird 8 wiedergeben.

//Edit: Gerade eben getestet:

printf("Anzahl bits: %i (%i bytes)",sizeof(unsigned long long)*8,sizeof(unsigned long long));

ergibt

Anzahl bits: 64 (8 bytes)

Soll heissen: Dein wert passt nicht in 8 byte, somit nicht in eine variable die nur 8 byte hat (z.B. unsigned long long)

Wenn du umbedingt größere werte brauchst würde ich dazu raten mit char arrays zu arbeiten (wenn es um text zu binär geht evtl sofort text zu binär, nicht den umweg über zahlen).

[Kugelfisch23]

Zitat von M3þh!$tø

in Dezimal, wenn ich es umwandel:

17063062071968289023

Auch ein `unsigned long long`-Datentyp kann nicht mehr als 64 Bits (Zahlen > 2^64) aufnehmen.

Zitat von Programmcode

[...]
unsigned long long zahl = 17063062071968289023;
[...]

Zitat von Compileroutput

foo.cpp:5:27: warning: integer constant is so large that it is unsigned
foo.cpp:5: warning: this decimal constant is unsigned only in ISO C90
foo.cpp:5: error: integer constant is too large for 'long' type

[M3þh!$tø]

Ok, danke euch beiden, dann werd ichs mal mit einem Array versuchen

Hoffentlich klappts dann!