Mit "Sscanf" String auf Int durchsuchen

Noch was... Wie würdet Ihr die "Rückwandlung" von dem String (10010 z.b.) in Dezimal machen?

Habs jetzt mal mit " strtoul(string, NULL, 2) " gelöst...
Dachte daran es selbst zu machen mit einer Maske wo jede Stelle Ihrem Wert zugedacht ist...

beginner88888

Sind die beiden Varianten soo schlecht??

Verzichte auf das strcpy und den lokalel String.

strcpy schrieb:

destination ... should not overlap in memory with source.

Zur Rückwandlung:
Genau dafür wurde strtoul ja gemacht.

Wenn du es trotzdem Probieren willst:

char binzahl[] = "10100101";
char *pc = binzahl;

unsigned int result = 0;

while (*pc) {
  result *= 2;
  result += (*pc -'0');
  ++pc;
}

Da fehlt aber noch der Test, ob es wirklich nur '0' oder '1' ist.
Du bist aber nicht auf die 2 als Basis beschränkt. Bis 10 geht das auch.

Und wenn du dich an http://www.c-plusplus.net/forum/p2376529#2376529 erinnerst, dann kannst du mit strchr und toupper sogar höhere Basen als 10 machen

Ok, Danke!

Die Meldung gab mein DevC++ nicht aus.
Ich weiß , das ist nicht die beste IDE, aber ich brauch was ziemlich kleines, was sich auch auf Arbeit auf unsere PC´s installieren lässt, ohne das die EDV mault..

pferdefreund

Eventuell einfach alles, was nicht '0'-'9' ist auf space setzen, dann sollte es
auf Anhieb funktionieren. Hab ich auch schon mal irgendwo gemacht.

Welche Meldung?
Meinst du die von strcpy?
Die gibt nicht der Compiler. Das steht in der Refernz / man-page zu strcpy.

Schau mal auf der Startseite vom diesem Unterforum.
Da gibt es eine Linkliste für Neulinge mit Links zu solchen Referenzen und auch zu den letzten Drafts von den verschidenen C Standards.

Ok, war ein Missverständinß. Dachte das gibt evtl. dein Compiler oder IDE aus.
Benutze als REferenz meistens :
http://www.cplusplus.com/reference/clibrary/

beginner_offl schrieb:

Ok, war ein Missverständinß. Dachte das gibt evtl. dein Compiler oder IDE aus.
Benutze als REferenz meistens :
http://www.cplusplus.com/reference/clibrary/

Dann schau da mal nach strcpy und lies es dir durch.
Da stammt das Zitat nämlich her.

Verzichte auf das strcpy und den lokalel String.

strcpy schrieb:

destination ... should not overlap in memory with source.

Wie soll er dann den String zurückgeben???

beginner88888

Das hab ich mittlerweile koplett überarbeitet, aber eine Frage ist berechtigt:

strcpy schrieb:

destination ... should not overlap in memory with source.

Wie ist das genau gemeint? Meine String-Rückgaben laufen in etwa immer so :

//in der Main: 
int buffer[max]   ;   // kümmert sich quasi um den speicher

// Funktion: 
char* foo( char* puffer){

// Meist Lokaler STring
strcpy(puffer, lokaler_String);
return puffer;

Ich denke mit "should not overlap in memory with source." ust die Arbeit auf dem "Original-String" gemeint, der evtl. dann strcpy auf sich selbst gelegt wird?
Weil so wie im obrigen Code mache ich´s meistens.

Könnte ich evtl. auch direkt den lokalen STring irgendwie returnen?

unsure schrieb:

Wie soll er dann den String zurückgeben???

Indem er bei char to_bin4(unsigned int value, char* string){* direkt die '0' und '1' in string ablegt.

strcpy schrieb:

destination ... should not overlap in memory with source.

Beispiel:

char text[100] = "Hallo Weltmeister!";

strcpy(text, text+6); 
//oder
strcpy(text+16, text);

Beispiel:

C:
char text[100] = "Hallo Weltmeister!";
 
strcpy(text, text+6);
//oder
strcpy(text+16, text);

Sorry, das check ich jetzt nicht. +6 +16 ??
Gehts nur darum das Quelle und Ziel unterschiedlich groß sind?

//in der Main:
int buffer[max]   ;   // kümmert sich quasi um den speicher

// Funktion:
char* foo( char* puffer){

// Meist Lokaler STring
strcpy(puffer, lokaler_String);
return puffer;

... ist aber Richtig oder?

SeppJ

Schreib mal ein ganz naives strcpy selber. Eines, das wirklich stumpf ein Zeichen nach dem anderen kopiert. Dann rufst du das mal so auf, wie in DirkBs Gegenbeispiel. Fällt dir was auf? Was passiert und warum?

beginner_offl schrieb:

Sorry, das check ich jetzt nicht. +6 +16 ??
Gehts nur darum das Quelle und Ziel unterschiedlich groß sind?

Ich zitiere dich mal aus http://www.c-plusplus.net/forum/p2378720#2378720 Zeile 23:

beginner_offl schrieb:

*(ch_ar+j)=dummy;         //oder hald ch_ar[j]

Also scheinst du doch Pointerarithmetik zu kennen.

Ja,da hast du recht. War etwas schnell geschoßen. An Pointerarithmetik hab ich da jetzt gar nicht gedacht. War Käse.

Das mit dem Überlappen hab ich jetzt kapiert. Dürfte dann undefiniertes Verhalten sein, wenn sich die Quelle Ziel überlappen.

strcpy(text, text+6); geht z.B. bei mir immer : Soll copy bei "W" von Weltmeister beginnen

strcpy(text+16, text); geht gar =>sollte Theoretisch !Hallo Weltmeister! ergeben?

@ SeppJ
Geht auch mit meinem Scopy nicht, habe die Funktion so gemacht :

void scopy(char *ziel, char*quelle){

   while  ((*(ziel++) = *(quelle++) )  != '\0' ) ;   

}

=> Das "echte" strcpy gibt doch nen Zeiger auf Char zurück... Das wäre dann ein Zeiger auf den Anfang der Zeichenkette...
Habe jetzt mal so angedacht:

char* scopy(char *ziel, char*quelle){

   char *begin;

   begin=&ziel[0];  
   while  ((*(ziel++) = *(quelle++) )  != '\0' ) ;   

   return begin;

Compiler motzt nicht bei mir, gehen tut´s auch, aber ein komisches Gefühl über die Rückgabe bleibt

beginner_offl schrieb:

strcpy(text+16, text); geht gar =>sollte Theoretisch !Hallo Weltmeister! ergeben?

Eigentlich sollte man "Hallo WeltmeisteHallo Weltmeister!" erwarten.
Aber da du ja das Ende überschreibst, kann das auch unendlich laufen.

Es gibt zum kopieren von Speicherbereichen zwei Funktionen: memcpy und memmove aus string.h.
Bei memcpy dürfen sich die Bereiche nicht überlappen. Bei memmove schon.

beginner_offl schrieb:

Compiler motzt nicht bei mir, gehen tut´s auch, aber ein komisches Gefühl über die Rückgabe bleibt

Warum? Das einzige was merkwürdig aussieht, ist begin=&ziel[0];
Kurz und knapp:

begin=ziel;

Eigentlich sollte man "Hallo WeltmeisteHallo Weltmeister!" erwarten.
Aber da du ja das Ende überschreibst, kann das auch unendlich laufen.

Arrghh Stimmt, ist ja copy , also fängt da an.

Jetzt mal ne Frage , die hier noch passt, die mir schon länger auf der Zunge brennt:

Kann man eigentlich irgendwo den Source-Code zu den Zugehörigen .h Dateien ansehen? Also von der C-Bibliothek ?

Weiterführend, ich benutze auf Arbeit DevC++.. da gibt´s nen Ordner wo die ganzen Standard Header drinn sind.... Aber wie funktioniert dann eigentlich das "Einbinden" der Funktionen genau?

Wenn ich im Programm
#include <string.h>

und dann eben : strcpy(x, y) mache... Wo liegt dann die "Referenz" zu strcpy?
Irgendwo muss doch der Code für strcpy herkommen / hinterlegt sein?

Mag sein das mich diese "grundliegende" Frage jetzt etwas disqualifizert, aber so ganz leuchtet mir das nicht ein.

SeppJ

beginner_off110 schrieb:

Kann man eigentlich irgendwo den Source-Code zu den Zugehörigen .h Dateien ansehen?

Klar, das sind ganz normale Headerdateien, die irgendwo auf deinem Computer sind. Wo genau, kommt auf dein System an. Erwarte nicht zu viel, da steht nur so etwas drin wie:

char * strcpy ( char * destination, const char * source );
char * strcat ( char * destination, const char * source );
int strcmp ( const char * str1, const char * str2 );

// usw.

Sind eben Headerdateien und die enthalten keine Definitionen (außer du machst C++ und guckst die STL an). Ich nehme an, es geht dir um die Definitionen der Funktionen.

Also von der C-Bibliothek ?

Nur, wenn der Hersteller sie veröffentlicht. Was bei Open Source Implementierungen (z.B. GCC) in der Regel der Fall ist.

Weiterführend, ich benutze auf Arbeit DevC++.. da gibt´s nen Ordner wo die ganzen Standard Header drinn sind.... Aber wie funktioniert dann eigentlich das "Einbinden" der Funktionen genau?

So wie sonst auch. Wie Header funktionieren ist dir bekannt? Die Standardbibliothek ist keine Zauberei, das funktioniert genau so, wie wenn du das selber machst.

Wenn ich im Programm
#include <string.h>

und dann eben : strcpy(x, y) mache... Wo liegt dann die "Referenz" zu strcpy?

Dann noch nirgendwo. Wie schon gesagt, es ist genau so, wie bei deinen eigenen Programmen^*. include fügt den Text des Headers ein, da drin stehen Deklarationen der Funktionen. Anhand dieser Deklarationen kann der Compiler die Korrektheit des Codes prüfen und dann allgemeinen Code erzeugen zum Aufruf einer solchen Funktion. Wo die Funktion tatsächlich ist, das interessiert den Compiler nicht.

Irgendwo muss doch der Code für strcpy herkommen / hinterlegt sein?

Der kommt dann ebenfalls aus einer ganz normalen Bibliotheksdatei, genau so als wenn du selber Bibliotheken schreibst. Der Linker sieht den vom Compiler erzeugten Aufruf, guckt in der Bibliothek nach der Funktion, setzt die passenden Werte ein und dann ist das Programm ausführbereit. Der einzige kleine Unterschied hier ist, dass die Standardbibliothek beim Linken normalerweise standardmäßig mit angegeben wird und du das nicht mehr selber machen musst und im Gegenteil den Linker speziell sagen musst, wenn du sie nicht möchtest. Manchmal musst du auch Teile der Standardbibliothek noch selber angeben (Bei den Mathefunktionen wird das gerne gemacht), dann ist das so, wie du es von eigenen Bibliotheken kennst.

Mag sein das mich diese "grundliegende" Frage jetzt etwas disqualifizert, aber so ganz leuchtet mir das nicht ein.

Ich habe das Gefühl, dass du den Normalfall nicht kennst. Wenn du nicht weißt, wie Bibliotheken funktionieren, dann nützt dir natürlich auch diese Erklärung wenig. Es macht dann wenig Sinn, das Verhalten einer speziellen Bibliothek zu diskutieren, wenn du nicht weißt, wovon überhaupt die Rede ist.

^*: Das ist übrigens nicht die ganze Wahrheit. Compiler können durchaus die Standardfunktionen erkennen und zwecks Optimierung die Aufrufe auch schon vor dem Linker einsetzen. Oder neuerdings kommt es in Mode, dass der Compiler gar keinen Code erzeugt, sondern dies auf den Linker übertragen wird, der dann mit voller Information den Code insgesamt besser optimieren kann. Aber ich denke, dieses Thema würde nun zu weit von der eigentlichen Frage wegführen.

Mir ist schon klar wie das einbinden von Header Files usw funktiniert.

Anhand dieser Deklarationen kann der Compiler die Korrektheit des Codes prüfen und dann allgemeinen Code erzeugen zum Aufruf einer solchen Funktion. Wo die Funktion tatsächlich ist, das interessiert den Compiler nicht.

=> Aber mich würde das interessieren

Der kommt dann ebenfalls aus einer ganz normalen Bibliotheksdatei, genau so als wenn du selber Bibliotheken schreibst

=>Meine "Bibliotheken" beschränken sich bis jetzt darauf, das ich mir Code, den ich evtl. mal wieder brauche wegspeichere. OK, hab ich noch nie gemacht.

Also die Funktion selbst ist dann quasi in irgendeiner Bibliotheksdatei gespeichert die ich eh nicht angucken kann, right?

Mit &quot;Sscanf&quot; String auf Int durchsuchen

Mit "Sscanf" String auf Int durchsuchen