Ja, genau das. Beide Funktionen haben ihre Stärken, sind aber in bestimmten Bereichen auch limitiert. Und da du ja deinen Eingabestring in (durch Spaces getrennte) Token zerlegen wolltest, habe ich mich gefragt, ob scanf() der richtige Weg für das Einlesen ist:

scanf type specifiers:
[...]
s: String of characters. This will read subsequent characters until a whitespace is found (whitespace characters are considered to be blank, newline and tab).

Quelle: http://www.cplusplus.com/reference/clibrary/cstdio/scanf.html

tmp[i]=strcpy(tmp[i],token);

Beid er Zeile liefert mir der Compiler:
"25 C:\Dev-Cpp\ersetzen.c incompatible types in assignment"

Was ist denn jetzt schon wieder?

Das kommt daher, weil strcpy() einen Pointer zurückliefert, tmp[] aber ein char-Array ist. Das geht sorum nicht. Aber den Rückgabewert brauchst du hier sowieso nicht, da strcpy() dir den Krams schon in tmp reinkopiert hat (zweiter Parameter wird in den ersten kopiert). Der Rückgabewert ist eigentlich nur dann sinnvoll zu gebrauchen, wenn du strcpy() direkt in einer anderen Funktion nutzen willst, also z.B.

size_t length = strlen( strcpy( tmp[i], token ) );
 

Okay...ich bin fast fertig....

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
  char text[100];
  char ersetzen[100];
  char teil_ers[100];

  printf(" Text eingeben: ");
  gets(text);
  printf("\n Welcher Teil soll erstezt werden? : ");
  gets(ersetzen);
  printf("\n durch was? :");
  gets(teil_ers);

  int i=0,count=0;
  char tmp[15][15];
  char * token;
 
  if(token=strtok(text," "))
  {
    strcpy(tmp[i],token);
    i++;
  while(token=strtok(NULL," "))
  {
     strcpy(tmp[i],token);
     i++;
     count++;
  }
  }
  i=0;
  while(strcmp(tmp[i],teil_ers))
  {
  if(i==1)
  {
  strcpy(tmp[i],teil_ers);
  break;
  }
  i++;
  count++;
  }
  char ausgabe[150];
  for(i=0;i<count;i++)
  {
  strcat(ausgabe,tmp[i]);
  strcat(ausgabe," ");
  }
  printf("%s\n\n",ausgabe);
  system("PAUSE");
  return 0;
}

So...einzige Problem ist, dass das Programm IMMER das zweite Wort ersetzt.

Das Problem liegt hier:

i=0;
while(strcmp(tmp[i],teil_ers)) {

    if(i==1) {
        strcpy(tmp[i],teil_ers);
        break;
    }
    i++;
    count++;
}
Der Code für das ersetzen des Wortes kann nur durchlaufen werden, wenn i==1 ist. Und das ist nunmal das 2. Wort (Nummerierung beginnt bei 0).
Was mich gerade wundert ist, warum es auch funktioniert, wenn das zweite Wort wirklich ersetzt werden soll. Dann müsste die Bedingung der while-Schleife eigentlich false sein...

EDIT: OK, habs gefunden. Du vergleichst ja nicht mit dem zu ersetzenden Wort ("ersetzen") sondern mit dem Ersatz an sich ("teil_ers") ... das ist hier sicher nicht gewollt!?! 

Lösungsvorschlag: Du durchläufst einfach die einzelnen Worte aus tmp[]. Dabei vergleichst du mit strcmp() auf Gleichheit mit dem zu ersetzenden Wort. Ist es gleich, hängst du den Ersatz an die Ausgabe, sonst das Originalwort.

das mit i==1 hab ich dann auch gefunden

und ich hab das jetzt geändert:
Ich vergleiche jetzt tmp mit dem Wort, welches ersetzt werden soll. Und dann überschreibt die if-Anweisung, das Wort mit dem anderen Teil

int compare;
  i=0;
  while(cmp=strcmp(tmp[i],ersetzen))
  {
  if(compare==1)
  {
  strcpy(tmp[i],teil_ers);
  break;
  }
  i++;
  count++;
  }

Aber das funktioniert nicht.
Vielleicht bin ich einfach im Moment zu müde, um darauf zu kommen. Aber eignetlich müsste das jetzt doch richtig sein oder?

Sollte dein Lösungsvorschlag so aussehen:
int compare;
  i=0;
  while(compare=strcmp(tmp[i],ersetzen))
  {
   if(compare==1)
    {
    strcpy(tmp[i],teil_ers);
    }
   else
    { strcat(ausgabe,tmp[i]);
    strcat(ausgabe," ");
    }
  i++;
 
 
 

Mit

while(cmp=strcmp(tmp[i],ersetzen))
wirst du nicht weit kommen. Wenn die Worte nämlich gleich sind, kommt ja 0=false raus und die Schleife wird nicht weiter durchlaufen. Dementsprechend wird auch nichts ersetzt. Vielleicht ist das der Denkfehler. strcmp() gibt 0 zurück, wenn die Strings *gleich* sind.

Ich dachte eher an sowas in der Art:
// i enthält vom Zerlegen ja noch die Anzahl der Token (+1)
int count = i;
char ausgabe[150] = "\0";
for( i = 0; i < count; i++ ) {
    if( strcmp( tmp[i], ersetzen ) == 0 ) {
strcat( ausgabe, teil_ers );
    } else {
        strcat( ausgabe, tmp[i] );
    }
    strcat( ausgabe, " " );
}
printf( ausgabe );


Ach ja...verdammt...den Fehler mach ich häufiger ???
stimmt while funktioniert nur solange die Funktion wahr ist.

Naja jetzt gehts

Danke.
 

Ich hab jetzt nochmal ne Frage?

Wan kann ich "char * beispiel" benutzen, und wann muss ich "char beispiel\[x\]" benutzen?

Was bedeutet dieses Sternchen?
Auf jedenfall heißt es nicht, das ich da soviel zeichen eingeben kann, wie ich will. 

Das Sternchen bedeutet, dass du einen Pointer ("Zeiger") hast. Der zeigt irgendwo auf eine Speicheradresse. Dort kann z.B. der Anfang eines Strings stehen. Das wäre dann ein char*. char x[123] reserviert Speicherplatz für 123 Zeichen. Dort kannst du einen String reinkopieren/reinschreiben. Wenn du nur einen Pointer anlegst, hast du aber noch keinen Speicherplatz. Du kannst da zwar u.U. was hinschreiben, was aber bedeutet, dass du Speicher nutzt, der dir nicht gehört (was irgendwie undefinierte Folgen hat).
char* wird z.B. für Parameter gerne genommen, weil dort eben dann nur der Pointer (meistens 4Byte) übergeben wird und nicht der ganze String (meistens Länge*1Byte). Der Pointer zeigt dann auf den Anfang des Strings. Das Ende ist bei Strings in C durch die 0 (oder '\0') erkennbar.

char text[100];
strcpy( text, "hallo Welt\n" );
// du kannst char[] einem char* zuweisen, zeigt dann auf den Anfang
char *ptr = text;
// Andersrum gehts nicht
char text2[100];
text2 = ptr;  //Fehler

Du kannst also in C nie "soviel reinschreiben wie du willst" (jedenfalls wüsste ich nicht wie). Daher ist es auch wichtig, dass du aufpasst, dass du nicht über die Grenzen deines reservierten Speichers hinausschreibst (Der Compiler prüft das nicht, das musst du selbst machen) und dass du am Ende deines Strings immer eine \0 hast, da sonst das Ende nicht gefunden wird und munter weiter gelesen/geschrieben wird (was wieder undefinierte Folgen hat). Aus diesem Grund gibt es von den meisten Funktionen auch zwei Varianten (z.B. strcpy() und strncpy()), wobei man bei der einen die Größe seines Buffers mit angeben kann, so dass man nie darüber hinaus schreibt. Man muss sich dann ggf. nur noch um die Nullterminierung kümmern...

So ich dneke nun kann ich mit einem kleinen Programm anfangen. Und zwar soll mein nächstes Programm Nullstellen von Funktionen berechnen.

Dazu soll man seine Funktion komplett slebst eingeben.
Die Art und Weise werde ich wohl vorgeben müssen, da ich noch nciht soo gut im zerscheinden von Strings bin

Dazu wollte ich in der eingebenen Funktion nach dem String ^2 suchen lassen. Wenn er vorhanden ist, wird die P-Q-Formel angewendet, sonst wird ganz "normal" gerechnet.

Mir reichen erstmal Funktionen des ersten und zweiten Grades. (bei dritten grad bin ich mir nicht merh sicher wie das mit den Nullstellen geht )

Naja am Ende soll das Programm slebst herausfinden was für eine Funktion das ist und dann die Nullstellen berechnen. Also im Prinzip wie beim TI Voyage 200 die Funktion (Nullst() )

Also erstmal sollen die Strings zerschntten werde strtok(funktion,"+").
In den Teilen mit strspn filter ich dann die Zahlen heraus die ggf. vor dem x stehen. Das Ergebnis kann ich dann ja in die Varibale (double) a[n] (oder? ???).
Und dann wir gerechnet. Wenn a[1] <0 wird a subtrahiert und sonst andersrum.

Ich werde mich dann melden wenn es schwierigkeiten gibt.

/* strspn example */
#include <stdio.h>
#include <string.h>

int main ()
{
  int i,count;
  char strtext[150] = "129th";
  char cset[150] = "1234567890";
  char test[150] = "\0";

  i = strspn (strtext,cset);
  printf ("The length of [url=http://www.computerhilfen.de/fachbegriffe-i-Initial.html][b]initial[/b][/url] number is %d.\n",i);
 
  count=i;
  for(i=0;i<count;i++)
  {
   if(i==0)
   {
   strcpy(strtext[i],test[i]);
   }
   else
   {
   strcat(strtext[i],test[i]);
   }
  }
  (int) x = test;
  printf("%s",test);
  printf"\n%i", x);
  return 0;
}

Also das Programm soll Erstmal die Zahlen am Anfang des Strings anzeigen.
Die ersten drei Zahlen sollen dann in in eine Variable geschrieben werden und anschließend in int umgewandlet werden. aber das Programm stürzt mal wieder ab (Ich hab das Talent zu einem Microsoft-Programmierer )

Kriegst du das überhaupt kompiliert? Ich nämlich nicht...
Außerdem macht deine for-Schleife wenig Sinn, du hast doch die Länge von dem String schon, da kannst du das in einem Rutsch kopieren. Und das Umwandeln nach int geht am besten mit atoi():

#include <stdio.h>
#include <string.h>

int main () {
    int i;
    char strtext[150] = "129th";
    char cset[150] = "1234567890";
    char test[150] = "\0";

    i = strspn ( strtext, cset );
    printf ( "The length of initial number is %d.\n", i );
 
    strncpy( test, strtext, i );
    int x = atoi( test );
 
    printf( "%s\n", test );
    printf( "%i\n", x );
    system( "PAUSE" );
    return 0;
}

Übrigens, noch ein kleiner Tipp zu den char*/char[]. Wenn du konstante Strings hast (wie hier strtext bzw. cset), kannst du die auch so anlegen:
char *strtext = "129th";
char *cset = "1234567890";
Dann wird die Länge automatisch an den zugewiesenen Wert angepasst. Allerdings kannst du die Strings dann nicht mehr ändern.

Okay...

Ich hab immer gedacht, char *beispiel, gilt für eine variable Länge. Das erklärt nun Einiges.

Danke nochmal.

Okay..

Also ich wollte mich jetzt erstmal darauf beschränken einfach Funktionen zu lösen.

wenn ich strtok() benutze, kann ich dann unterscheiden welches Zeichen aufgerteten ist?

Beispielsweise Teile ich einen String mit Hilfe von + und - auf. Ich möchte ja die Zahlen herausfiltern, aber ich brauch ja auch noch die Vorzeichen.