Wie nach 10. Semikolon String einlesen

[DEV0 (Gast)]

Hi,
wie kann man in C am schnellsten nach 10. Semikolon einen String 
einlesen. Man könnte z.B. 10-leere while Schleifen nehmen, ist nur 
redundant :-)

[Peter (Gast)]

strtoken / strtokencount

[Peter (Gast)]

char *tmp = "1;2;3;4;5;6;7;8;9;10,asf,adf,asdfasdf,";
int i = 0;
while ( i < 10 ) {
   if ( *tmp == ';' ) 
      ++i;
   ++tmp;
}

printf("%s", tmp );

so in etwas, man sollte aber noch dafür sorgen das nichts schief geht 
wenn es keine 10 ; gibt.

[DEV0 (Gast)]

hab einen anwendungspezifischen compiler, der keine includes machen 
kann.

[DEV0 (Gast)]

Pointer gehen auch nicht :-(

[Karl H. (kbuchegg)]

DEV0 schrieb:
> Pointer gehen auch nicht :-(

Dann machs über Array-Zugriffe.
Das Prinzip ist doch dasselbe:
Den String Zeichen für Zeichen durchgehen und mitzählen wieviele ; man 
angetroffen hat. Aus der Schleife gehts raus, wenn der String zu Ende 
ist, oder eben wenn 10 Stück ; angetroffen wurden.

[Karl H. (kbuchegg)]

DEV0 schrieb:
> hab einen anwendungspezifischen compiler, der keine includes machen
> kann.

Dann nenn das Ding bitte nicht C-Compiler!

Den mit den Einschränkungen ist das alles mögliche, nur nicht C.

[Xeraniad X. (xeraniad)]

#include <iostream.h>

  /* g++ -Wno-deprecated -I/usr/include/c++/4.1.3/backward dlm.cpp -o dlm ; dlm ; rm dlm */

  void cut ( char const src [/*1 +cpc*/],   /* source      string */
             char       dst [/*1 +cpc*/],   /* destination " */
             char       dlm,                /* delimiter character */
             int        inx)                /* desired segment index */
  { int               s_i = 0,
                      d_i = 0;
    int               cnt = 0;
    while (('\0' != src [s_i]) && (inx > cnt)) {
      if (dlm == src [s_i])  ++ cnt;
      ++ s_i;
    }  /* while not at end of source string and more delimiters expected */
    while (('\0' != src [s_i]) && (dlm != src [s_i])) {
      dst [d_i] = src [s_i];  ++ d_i;
      ++ s_i;
    }  /* copy */
    dst [d_i] = '\0';  /* terminate */
    return;
  }  /* cut */

  #define CPC  31             /* capacity */
int main (int argc, char const *argv [])
{ char   const src [1 +CPC] = "0;1;2;3;4;5;6;7;8;9;10;11;";
  char         dst [1 +CPC] = "?";

  cut (src, dst, ';', 10);
  cout << "dst: \"" << dst << "\"." << endl;
  
  return 0;
}  /* main */

[Rufus Τ. F. (rufus)]

Abgesehen davon, daß dieser "Sourcecode" formatiert ist wie 'ne 
Klobürste, ist das C++. Womit der Threadstarter vermutlich noch viel 
weniger anfangen können wird.

[Peter (Gast)]

Xeraniad X. schrieb:
> void cut ( char const src [/*1 +cpc*/]
> src [s_i]
das wird wohl schief gehen, weil man ja kein Zeiger übergibt, danach 
lieft man irgentetwas vom Stack aus.

[Karl H. (kbuchegg)]

Ich finde: die Aufgabenstellung ist so trivial, dass sie der 
Fragesteller alleine hinkriegen MUSS, wenn er sich auch nur in die Nähe 
des Begriffs "Programmierer" katapultieren will. Wenn er sich dann auch 
noch in die Nähe von "Softwareentwickler" schiessen will, dann muss er 
auch noch die richtige Idee dazu haben, zumal die nun wirklich nicht 
schwer zu finden ist.

Wie oft ein Zeichen in einem String vorkommt, ist Einsteigerniveau der 
6. oder 7. Unterrichtseinheit, gleich nachdem man erzählt bekommen hat, 
wie Strings in C funktionieren (aufbauend auf dem Begriff Array aus 2 
Stunden vorher).

[Peter (Gast)]

Peter schrieb:
> das wird wohl schief gehen, weil man ja kein Zeiger übergibt, danach
> lieft man irgentetwas vom Stack aus.

sorry main fehler, das [] habe ich übersehen. Bei dieser Formatiertung 
auch kein wunder.

[Karl H. (kbuchegg)]

Peter schrieb:
> Xeraniad X. schrieb:
>> void cut ( char const src [/*1 +cpc*/]
>> src [s_i]
> das wird wohl schief gehen, weil man ja kein Zeiger übergibt, danach
> lieft man irgentetwas vom Stack aus.

Das ist schon in Ordnung.

Der Syntaktische Zucker

void foo( char a[] )
{
  ...
}

ist nichts anderes als der Versuch, den automatischen Pointer bei 
Array-Übergabe syntaktisch zu verstecken. Abgesehen davon passiert unter 
der Decke genau das gleiche wie bei

void foo( char * a )
{
  ...
}

Warum man diese Syntax in C erlaubt hat?
Keine Ahnung. Ausser das sich Neulinge etwas leichter tun, hat sie kaum 
Vorteile. Im Prototypen ist vielleicht etwas besser ersichtlich, dass 
die Funktion hier

void foo( char a[] );

ein bereits vorhandenes Array erwartet, während man bei

void foo( char * a );

nicht so recht weiß, wass es mit dem Pointer auf sich hat und sich erst 
mal schlau machen muss.

[DEV0 (Gast)]

@Buchegger: kannst das mal konkretisieren?

[Karl H. (kbuchegg)]

Was soll ich konkretisieren?

Meiner Meinung nach wurde schon alles gesagt und (leider) auch in einem 
Codebeispiel gezeigt.

[Johann (Gast)]

DEV0 schrieb:
> @Buchegger: kannst das mal konkretisieren?

Oh Mann, lies doch erst einmal ein C-Buch!!

[DEV0 (Gast)]

der code ist murx.

[Karl H. (kbuchegg)]

Er ist (für meinen Geschmack) schlecht formatiert. Aber Murx ist er 
nicht.

Im übrigen: Du hast die Lösungsidee, du hast deinen C-Compiler. Du hast 
sogar ein Musterbeispiel, welches diese Lösungsidee implementiert.
Was also hindert dich?

[Tobi (Gast)]

DEV0 schrieb:
> der code ist murx.

Welcher? Hier stehen zwei Codebeispiele. Außerdem ist das nun wirklich 
keine große Aufgabe. Da du kein C benötigst, sondern anscheinend nur 
irgendeine einen Murx der eine Art beschnittenes C ist, sollte es dir 
möglich sein den Code von Peter entsprechend anzupassen. Danach musst du 
dir dann nur noch Gedanken machen wie du auf nicht vorhandene Semikolons 
reagierst.

Schleife -> 10. Semikolon suchen -> Bis Terminierung kopieren... so 
schwer ist das nicht.

[Xeraniad X. (xeraniad)]

Auch für Klobürsten gilt: form follows function ;-)