Ausgabe in einer Zeile

MFK

Schneid einfach das letzte Zeichen ab, wenn es ein '\n' ist:

if(pcInput1[LaengeInput1-1] == '\n')
{
    pcInput1[LaengeInput1-1] = '\0';
}

cHillb3rT

ah danke für den Tipp... jetzt hab ich noch die Variablen initialisiert, damit es keinen Speicheradressenfehler gibt:

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

#define MAX 50

int main(int argc, char* argv[])
{
  char *pcInput1,
       *pcInput2,
       *Ergebnis;
  int LaengeInput1, LaengeInput2, LaengeErgebnis;

  /* Den beiden Variablen wird der Speicherbereich zugewiesen,
  ab dem allokiert werden soll  */
  pcInput1 = (char*)malloc(MAX);
  pcInput2 = (char*)malloc(MAX);

  /* Initialisierung der Inteegr-Variablen */
  LaengeInput1 = 0;
  LaengeInput2 = 0;
  LaengeErgebnis = 0;

  /* Eingabeblock und Auslesen der Länge der Zeichenkette: Problematik hierbei ist, dass
  fgets die Zeile einliest, aber dabei den Zeilentrenner miteinliest. Dadurch haben
  wir einen Wert mehr, als die eingegebenen Buchstaben. */
  fgets(pcInput1, MAX, stdin);
  fgets(pcInput2, MAX, stdin);
  LaengeInput1 = strlen(pcInput1);
  LaengeInput2 = strlen(pcInput2);

  /* Hierbei wird der Zeilentrenner gesucht, der bei fgets miteingelesen wurde und
  dadurch Fehler in der Ausgabe eingefügt worden sind. */
  if(pcInput1[LaengeInput1-1] == '\n')
    if (pcInput2[LaengeInput2-1] == '\n')
  {
    pcInput1[LaengeInput1-1] = '\0';
    pcInput2[LaengeInput2-1] = '\0';
  }
  /* Nachdem man die Länge der beiden Eingaben hat, kann man den benötigten Speicher-
  bereich für das Ergebnis eintragen. Dabei brauch man aber auch nochmal ein Zeichen
  mehr, als die Eingabe, da das Nullzeichen am Ende der Ergebniszeile ebenfalls eine
  Stelle benötigt */
  Ergebnis = (char*)malloc(LaengeInput1 + LaengeInput2+1);
  printf("Anzahl der Zeichen bei Eingabe 1: %d\n", LaengeInput1-1);
  printf("Anzahl der Zeichen bei Eingabe 2: %d\n", LaengeInput2-1);
  Ergebnis = strcat(pcInput1,pcInput2);
  printf("%s\n", Ergebnis);

  /* Ausgabe der Länge des Ergebnisses */
  LaengeErgebnis = LaengeInput1-1 + LaengeInput2-1;
  printf("Ausgabe der Länge des Ergebnisses: %d\n", LaengeErgebnis); 

  /* Freigabe des Speichers */
  free(pcInput1);
  free(pcInput2);
  free(Ergebnis);
  return 0;
  }

cHillb3rT

Der nächste Schritt, den ich jetzt gemacht habe, ist dieser, das man "strlen" und "strcat" selbst schreibt, damit man die <string.h> nicht benötigt. Ich hab es soweit gelöst, dass die Funktionen funktionieren, aber es gibt im Programm selbst noch einen Fehler:

#include <stdio.h>
#include <alloc.h>

#define MAX 50

int strlen(char *s);
void strcat(char *s, char *t);

#include <stdio.h>
#include <alloc.h>

#define MAX 50

int main(int argc, char* argv[])
{
  char *pcInput1,
       *pcInput2,
       *Ergebnis;
  int LaengeInput1, LaengeInput2, LaengeErgebnis;

  /* Den beiden Variablen wird der Speicherbereich zugewiesen,
  ab dem allokiert werden soll  */
  pcInput1 = (char*)malloc(MAX);
  pcInput2 = (char*)malloc(MAX);

  /* Initialisierung der Inteegr-Variablen */
  LaengeInput1 = 0;
  LaengeInput2 = 0;
  LaengeErgebnis = 0;

  /* Eingabeblock und Auslesen der Länge der Zeichenkette: Problematik hierbei ist, dass
  fgets die Zeile einliest, aber dabei den Zeilentrenner miteinliest. Dadurch haben
  wir einen Wert mehr, als die eingegebenen Buchstaben. */
  fgets(pcInput1, MAX, stdin);
  fgets(pcInput2, MAX, stdin);
  LaengeInput1 = strlen(pcInput1);
  LaengeInput2 = strlen(pcInput2);

  /* Hierbei wird der Zeilentrenner gesucht, der bei fgets miteingelesen wurde und
  dadurch Fehler in der Ausgabe eingefügt worden sind. */
  if(pcInput1[LaengeInput1-1] == '\n')
    if (pcInput2[LaengeInput2-1] == '\n')
  {
    pcInput1[LaengeInput1-1] = '\0';
    pcInput2[LaengeInput2-1] = '\0';
  }
  /* Nachdem man die Länge der beiden Eingaben hat, kann man den benötigten Speicher-
  bereich für das Ergebnis eintragen. Dabei brauch man aber auch nochmal ein Zeichen
  mehr, als die Eingabe, da das Nullzeichen am Ende der Ergebniszeile ebenfalls eine
  Stelle benötigt */
  Ergebnis = (char*)malloc(LaengeInput1 + LaengeInput2+1);
  printf("Anzahl der Zeichen bei Eingabe 1: %d\n", LaengeInput1-1);
  printf("Anzahl der Zeichen bei Eingabe 2: %d\n", LaengeInput2-1);
  Ergebnis = strcat(pcInput1,pcInput2);
  printf("%s\n", Ergebnis);

  /* Ausgabe der Länge des Ergebnisses */
  LaengeErgebnis = LaengeInput1-1 + LaengeInput2-1;
  printf("Ausgabe der Länge des Ergebnisses: %d\n", LaengeErgebnis); 

  /* Freigabe des Speichers */
  free(pcInput1);
  free(pcInput2);
  free(Ergebnis);
  return 0;
  }

int strlen(char *s)
{
  char *p = s;
  while (*p != '\0')
    p++;
  return p - s;
}

void strcat(char *s, char *t)
{
  while (*s)
    s++;
  while(*s++ = *t++)
  ;
}

Soweit ist es richtig, bis auf den Fehler in dieser Zeile:

Ergebnis = strcat(pcInput1,pcInput2);

An sich müsste es gehen.....

cHillb3rT

void strcat(char *s, char *t) 
{ 
  while (*s) 
    s++; 
  while(*s++ = *t++) 
  ; 
}

Nach meiner Ansicht resultiert der Fehler aus dieser Funktion, weswegen diese in dem Hauptprogramm nicht richtig eingesetzt werden kann.

mata

ohne kommentar. denk mal drüber nach, warum es jetzt auf einmal geht..

#include <stdio.h> 
#include <malloc.h> 

#define MAX 50 

int strlen(char *s); 
void strcat(char *s, char *t); 

int main(int argc, char* argv[]) 
{ 
  char *pcInput1, 
       *pcInput2, 
       *Ergebnis; 
  int LaengeInput1, LaengeInput2, LaengeErgebnis; 

  /* Den beiden Variablen wird der Speicherbereich zugewiesen, 
  ab dem allokiert werden soll  */ 
  pcInput1 = (char*)malloc(MAX); 
  pcInput2 = (char*)malloc(MAX); 

  /* Initialisierung der Inteegr-Variablen */ 
  LaengeInput1 = 0; 
  LaengeInput2 = 0; 
  LaengeErgebnis = 0; 

  /* Eingabeblock und Auslesen der Länge der Zeichenkette: Problematik hierbei ist, dass 
  fgets die Zeile einliest, aber dabei den Zeilentrenner miteinliest. Dadurch haben 
  wir einen Wert mehr, als die eingegebenen Buchstaben. */ 
  fgets(pcInput1, MAX, stdin); 

  fgets(pcInput2, MAX, stdin); 
  LaengeInput1 = strlen(pcInput1); 
  LaengeInput2 = strlen(pcInput2); 

  /* Hierbei wird der Zeilentrenner gesucht, der bei fgets miteingelesen wurde und 
  dadurch Fehler in der Ausgabe eingefügt worden sind. */ 
  if(pcInput1[LaengeInput1-1] == '\n') 
    if (pcInput2[LaengeInput2-1] == '\n') 
  { 
    pcInput1[--LaengeInput1] = '\0'; 
    pcInput2[--LaengeInput2] = '\0'; 
  } 
  /* Nachdem man die Länge der beiden Eingaben hat, kann man den benötigten Speicher- 
  bereich für das Ergebnis eintragen. Dabei brauch man aber auch nochmal ein Zeichen 
  mehr, als die Eingabe, da das Nullzeichen am Ende der Ergebniszeile ebenfalls eine 
  Stelle benötigt */ 
  //Ergebnis = (char*)malloc(LaengeInput1 + LaengeInput2+1); 
  printf("Anzahl der Zeichen bei Eingabe 1: %d\n", LaengeInput1-1); 
  printf("Anzahl der Zeichen bei Eingabe 2: %d\n", LaengeInput2-1); 
  strcat(pcInput1,pcInput2); 
  printf("%s\n", pcInput1); 

  /* Ausgabe der Länge des Ergebnisses */ 
  LaengeErgebnis = LaengeInput1-1 + LaengeInput2-1; 
  printf("Ausgabe der Länge des Ergebnisses: %d\n", LaengeErgebnis); 

  /* Freigabe des Speichers */ 
  free(pcInput1); 
  free(pcInput2); 
  free(Ergebnis); 
  return 0; 
  } 

int strlen(char *s) 
{ 
  char *p = s; 
  while (*p != '\0') 
    p++; 
  return p - s; 
} 

void strcat(char *s, char *t) 
{ 
  while (*s) 
    s++; 
  while(*s++ = *t++) 
  ; 
}

cHillb3rT

Ich soll aber das Ergebnis in einem Pointer schreiben, der eine bestimmte reservierte Größe hat.

@mata:
Bei dir ist das so, dass du dies nicht tust !

AJ

cHillb3rT schrieb:

Ergebnis = strcat(pcInput1,pcInput2);

void strcat(char *s, char *t) 
{ 
  while (*s) 
    s++; 
  while(*s++ = *t++) 
  ; 
}

Hmmm was wird da wohl nicht zusammenpassen?? Überleg mal genau, was du von der Funktion erwartest (komplett!) und was die Funktion alles tut und was sie nicht tut, was du aber erwartest, das sie tut.

hephaistos6

überleg dir einfach, was void zurückgibt

cHillb3rT

So ich bin das Problem mal so angegangen !:

#include <stdio.h>
#include <alloc.h>

#define MAX 50

int strlen(char *s);
void strcat(char *s, char *t);

#include <stdio.h>
#include <alloc.h>

#define MAX 50

int main(int argc, char* argv[])
{
  char *pcInput1,
       *pcInput2,
       *pcErgebnis;
  int LaengeInput1, LaengeInput2, LaengeErgebnis;

  /* Den beiden Variablen wird der Speicherbereich zugewiesen,
  ab dem allokiert werden soll  */
  pcInput1 = (char*)malloc(MAX);
  pcInput2 = (char*)malloc(MAX);

  /* Initialisierung der Inteegr-Variablen */
  LaengeInput1 = 0;
  LaengeInput2 = 0;
  LaengeErgebnis = 0;

  /* Eingabeblock und Auslesen der Länge der Zeichenkette: Problematik hierbei ist, dass
  fgets die Zeile einliest, aber dabei den Zeilentrenner miteinliest. Dadurch haben
  wir einen Wert mehr, als die eingegebenen Buchstaben. */
  fgets(pcInput1, MAX, stdin);
  fgets(pcInput2, MAX, stdin);
  LaengeInput1 = strlen(pcInput1);
  LaengeInput2 = strlen(pcInput2);

  /* Hierbei wird der Zeilentrenner gesucht, der bei fgets miteingelesen wurde und
  dadurch Fehler in der Ausgabe eingefügt worden sind. */
  if(pcInput1[LaengeInput1-1] == '\n')
    if (pcInput2[LaengeInput2-1] == '\n')
  {
    pcInput1[LaengeInput1-1] = '\0';
    pcInput2[LaengeInput2-1] = '\0';
  }
  /* Nachdem man die Länge der beiden Eingaben hat, kann man den benötigten Speicher-
  bereich für das Ergebnis eintragen. Dabei brauch man aber auch nochmal ein Zeichen
  mehr, als die Eingabe, da das Nullzeichen am Ende der Ergebniszeile ebenfalls eine
  Stelle benötigt */
  pcErgebnis = (char*)malloc(LaengeInput1 + LaengeInput2+1);
  pcErgebnis = 0;
  printf("Anzahl der Zeichen bei Eingabe 1: %d\n", LaengeInput1-1);
  printf("Anzahl der Zeichen bei Eingabe 2: %d\n", LaengeInput2-1);

  strcat(pcInput1, pcErgebnis);
  strcat(pcInput2, pcErgebnis);
  printf("%s\n", pcErgebnis);

  /* Ausgabe der Laenge des Ergebnisses */
  LaengeErgebnis = LaengeInput1-1 + LaengeInput2-1;
  printf("Ausgabe der Länge des Ergebnisses: %d\n", LaengeErgebnis); 

  /* Freigabe des Speichers */
  free(pcInput1);
  free(pcInput2);
  free(pcErgebnis);
  return 0;
  }

int strlen(char *s)
{
  char *p = s;
  while (*p != '\0')
    p++;
  return p - s;
}

void strcat(char *s, char *t)
{

  while (*s)
    s++;
  while(*s++ == *t++)
  ;
}

AJ

cHillb3rT schrieb:

So ich bin das Problem mal so angegangen !:

#include <stdio.h>
#include <alloc.h>

#define MAX 50

int strlen(char *s);
void strcat(char *s, char *t);

Schon nach dieser Zeile ist klar, dass du es immer noch nicht verstanden hast. Schau dir doch mal die Deklaration von strcat in einer Dokumentation an. Vielleicht kommst du dann drauf.

cHillb3rT

#include <stdio.h>
#include <alloc.h>

#define MAX 50

int strlen(char *s);

#include <stdio.h>
#include <alloc.h>

#define MAX 50

int main(int argc, char* argv[])
{
  char *pcInput1,
       *pcInput2,
       *pcErgebnis;
  int LaengeInput1, LaengeInput2, LaengeErgebnis, i;

  /* Den beiden Variablen wird der Speicherbereich zugewiesen,
  ab dem allokiert werden soll  */
  pcInput1 = (char*)malloc(MAX);
  pcInput2 = (char*)malloc(MAX);

  /* Initialisierung der Inteegr-Variablen */
  LaengeInput1 = 0;
  LaengeInput2 = 0;
  LaengeErgebnis = 0;

  /* Eingabeblock und Auslesen der Länge der Zeichenkette: Problematik hierbei ist, dass
  fgets die Zeile einliest, aber dabei den Zeilentrenner miteinliest. Dadurch haben
  wir einen Wert mehr, als die eingegebenen Buchstaben. */
  fgets(pcInput1, MAX, stdin);
  fgets(pcInput2, MAX, stdin);
  LaengeInput1 = strlen(pcInput1);
  LaengeInput2 = strlen(pcInput2);

  /* Hierbei wird der Zeilentrenner gesucht, der bei fgets miteingelesen wurde und
  dadurch Fehler in der Ausgabe eingefügt worden sind. */
  if(pcInput1[LaengeInput1-1] == '\n')
    if(pcInput2[LaengeInput2-1] == '\n')
  {
    pcInput1[LaengeInput1-1] = '\0';
    pcInput2[LaengeInput2-1] = '\0';
  }
  /* Nachdem man die Länge der beiden Eingaben hat, kann man den benötigten Speicher-
  bereich für das Ergebnis eintragen. Dabei brauch man aber auch nochmal ein Zeichen
  mehr, als die Eingabe, da das Nullzeichen am Ende der Ergebniszeile ebenfalls eine
  Stelle benötigt */
  pcErgebnis = (char*)malloc(LaengeInput1 + LaengeInput2+1);
  pcErgebnis = 0;
  printf("Anzahl der Zeichen bei Eingabe 1: %d\n", LaengeInput1-1);
  printf("Anzahl der Zeichen bei Eingabe 2: %d\n", LaengeInput2-1);

  /* Ausgabe der beiden Zeilen mit der Funktion, aber ohne Überschreibung in einen
  Ziel-Pointer, der einen genau passenden allokierten Bereich besitzt. */
  pcErgebnis = pcInput1;
  printf("\nAusgabe des Ergebnisses %s", pcErgebnis);
  pcErgebnis = pcInput2;
  printf("%s", pcErgebnis);

  /* Ausgabe der Laenge des Ergebnisses */
  LaengeErgebnis = LaengeInput1-1 + LaengeInput2-1;
  printf("\nAusgabe der Länge des Ergebnisses: %d\n", LaengeErgebnis); 

  /* Freigabe des Speichers */
  free(pcInput1);
  free(pcInput2);
  free(pcErgebnis);
  return 0;
}

int strlen(char *s)
{
  char *p = s;
  while (*p != '\0')
    p++;
  return p - s;
}

AJ

Ich dachte du möchtest strcat() nachprogrammieren. Jetzt lässt du es ja ganz weg.

cHillb3rT

AJ schrieb:

Ich dachte du möchtest strcat() nachprogrammieren. Jetzt lässt du es ja ganz weg.

Ich hab erstmal die Lösung hier probiert, aber ich will immer noch das strcat() nachbauen, damit ich die gleiche Funktion habe.

Ich komme damit aber nicht so voran, wie ich mir das vorstelle und daher hab ich kurzerhand was anderes gemacht, was ich auch noch in einem anderen Programm gebrauchen kann.

cHillb3rT

Also ich hab den Auftrag ohne Funktion des jetzt zu machen. Dabei sollen die Eingabezeilen ausgelesen werden und die chars einzeln ausgelesen werden:

for (index1 = 0; index1 <= (LaengeInput1-1); index1++)
  {
    Buchstabe = *(pcInput1+index1);
    *(pcErgebnis+index1) = Buchstabe;
  }

  for (index2 = 0; index2 <= (LaengeInput2-1); index2++)
  {
    Buchstabe = *(pcInput2+index1);
    *(pcErgebnis+index2) = Buchstabe;
  }

Soweit hab ich den Code, doch ich bekomme immer wieder einen Fehler, wenn das Programm in diese Zeile sprint:

*(pcErgebnis+index1) = Buchstabe;

Soweit ich sehe, ist es ein Speicheradressenfehler, aber ich weiß nicht woher dieser kommt, da pcErgebnis ausreichend Speicher bietet.

AJ

Um mehr sagen zu können, müsste man wissen, was in Input steht und wieviel Speicher für Ergebnis reserviert ist.

cHillb3rT

So weit so gut !

#include <stdio.h>
#include <alloc.h>

#define MAX 50

int strlen(char *s);
void Kopieren(char *s, char *t);

#include <stdio.h>
#include <alloc.h>

#define MAX 50

int main(int argc, char* argv[])
{
  char *pcInput1,
       *pcInput2,
       *pcErgebnis,
       Buchstabe,
       ZwErgebnis;
  int LaengeInput1,
      LaengeInput2,
      LaengeErgebnis,
      index1,
      index2,
      index3;

  /* Den beiden Variablen wird der Speicherbereich zugewiesen,
  ab dem allokiert werden soll  */
  pcInput1 = (char*)malloc(MAX);
  pcInput2 = (char*)malloc(MAX);

  /* Initialisierung der Inteegr-Variablen */
  LaengeInput1 = 0;
  LaengeInput2 = 0;
  LaengeErgebnis = 0;

  /* Eingabeblock und Auslesen der Länge der Zeichenkette: Problematik hierbei ist, dass
  fgets die Zeile einliest, aber dabei den Zeilentrenner miteinliest. Dadurch haben
  wir einen Wert mehr, als die eingegebenen Buchstaben. */
  fgets(pcInput1, MAX, stdin);
  fgets(pcInput2, MAX, stdin);
  LaengeInput1 = strlen(pcInput1);
  LaengeInput2 = strlen(pcInput2);

  /* Hierbei wird der Zeilentrenner gesucht, der bei fgets miteingelesen wurde und
  dadurch Fehler in der Ausgabe eingefügt worden sind. */
  if(pcInput1[LaengeInput1-1] == '\n')
    if(pcInput2[LaengeInput2-1] == '\n')
  {
    pcInput1[LaengeInput1-1] = '\0';
    pcInput2[LaengeInput2-1] = '\0';
  }
  /* Nachdem man die Länge der beiden Eingaben hat, kann man den benötigten Speicher-
  bereich für das Ergebnis eintragen. Dabei brauch man aber auch nochmal ein Zeichen
  mehr, als die Eingabe, da das Nullzeichen am Ende der Ergebniszeile ebenfalls eine
  Stelle benötigt */
  LaengeErgebnis = (LaengeInput1-1 + LaengeInput2-1+1);
  pcErgebnis = (char*)malloc(LaengeErgebnis);
  //pcErgebnis = 0;
  printf("Anzahl der Zeichen bei Eingabe 1: %d\n", LaengeInput1-1);
  printf("Anzahl der Zeichen bei Eingabe 2: %d\n", LaengeInput2-1);

  /* Ausgabe der beiden Zeilen mit der Funktion, aber ohne Überschreibung in einen
  Ziel-Pointer, der einen genau passenden allokierten Bereich besitzt. */
  for (index1 = 0; index1 <= (LaengeInput1-1); index1++)
  {
    Buchstabe = *(pcInput1+index1);
    *(pcErgebnis+index1) = Buchstabe;
  }

  for (index2 = 0; index2 <= (LaengeInput2-1); index2++)
  {
    Buchstabe = *(pcInput2+index2);

    *(pcErgebnis+index2) = Buchstabe;
  }
  printf("\nAusgabe des Ergebnisses %s", pcErgebnis);

  /* Ausgabe der Laenge des Ergebnisses */
  LaengeErgebnis = LaengeInput1-1 + LaengeInput2-1;
  printf("\nAusgabe der Länge des Ergebnisses: %d\n", LaengeErgebnis);

  /* Freigabe des Speichers */
  free(pcInput1);
  free(pcInput2);
  free(pcErgebnis);
  getch();
  return 0;
}

int strlen(char *s)
{
  char *p = s;
  while (*p != '\0')
    p++;
  return p - s;
}

Es geht nun darum die ausgelesene zweite Zeile an die ausgelesen erste Zeile dran zu hängen. In dieser Zeile werden die Zeilen ausgelesen und den Pointern zugewiesen, aber ich möchte nun, dass Input2 direkt nach der ausgelesenen Zeile dran gehängt wird:

for (index1 = 0; index1 <= (LaengeInput1-1); index1++)
  {
    Buchstabe = *(pcInput1+index1);
    *(pcErgebnis+index1) = Buchstabe;
  }

  for (index2 = 0; index2 <= (LaengeInput2-1); index2++)
  {
    Buchstabe = *(pcInput2+index2);

    *(pcErgebnis+index2) = Buchstabe;
  }
  printf("\nAusgabe des Ergebnisses %s", pcErgebnis);

Eingabe 1: alexander
Eingabe 2: Franz

Ausgabe: alexanderFranz

Fehler der derzeit auftritt: Nur Eingabe 2 wird ausgegeben. Der Fehler liegt im obigen Quellcode-Abschnitt !

hohesC

Servus!
Es sollen 2 sachen eingelesen werden und dann so:

Eingabe1: Hal
Eingabe2: lo

Ausgabe: Hallo

wie in diesem Bsp. ausgegeben werden.
Ich habe eine lösung mit selbst geschriebener Funktion:

#include <stdio.h>
#include <conio.h>

#define SIZE 30

void copy(char *a,char *b);

int main()
{
	char *p1,*p2;
	char a[2*SIZE]={0},b[SIZE]={0};

	printf("Eingabe1:");
	fgets(a,SIZE,stdin);

	printf("Eingabe2:");
	fgets(b,SIZE,stdin);

	p1=&a[0];
	p2=&b[0];

	copy(p1,p2);
	printf("\nAusgabe: ");
	fputs(a,stdout);
	getch();
	return(0);
}

void copy(char *a,char *b)
{
	int x=0,p=0;

	while(a[p])
	{
		p++;
	}
	p--;
	for(x=0;x<=SIZE;x++)
	{
		a[p]=b[x];
		p++;
	}
}

mfg hohesC

die Funktion copy(a,b); fügt an a den array b an!

cHillb3rT

okay das ist auch eine Lösungsmöglichkeit

Zu deinem Quellcode hab ich aber einige Fragen !

1. Frage: Wieso benutzt du bei char a zweimal SIZE ? Soll darin das Ergebnis sein, wodurch du mehr Platz brauchen würdest ?!? Und wieso stellst du 0 in die geschweiften Klammern ?

char a[2*SIZE]={0},b[SIZE]={0};

2. Frage: Was wird hier genau gemacht ? Wird hier "p1" Null zugewiesen ?

p1=&a[0];

hohesC

Da ich für b 30 habe benötige ich für a das doppelte!!!
weil ich ja b an a dran hänge.
wenn der benutzer für a 30 zeichen eingibt kann man ja nix mehr anhängen!!

p1=&a[0];

p1 ist ein pointer dem ich die adresse, des ersten elements des arrays a übergebe.

Und wieso stellst du 0 in die geschweiften Klammern ?

Ich setze alles auf 0!

mfg hohesC

cHillb3rT

ah jetzt verstehe ich.... nun ist aber meine Aufgabe in diesem Beispiel, dass ich das Ergebnis in einen Pointer schreibe.

Prinzip:
pcInput1 + pcInput2 = pcErgebnis

"pcErgebnis" soll das Ergebnis der zusammengesetzten Zeile enthalten !
An diesem Problem sitze ich schon länger, weil mit zwei Variablen hab ich es schon gut hinbekommen !