strcat erzeugt Speicherzugriffsfehler

virtuell Realisticer

Hi,

ich wuerde es so machen:

/*
  speicher fuer 255 zeichen reservieren,
  bei pfadangaben geht man IMHO von einer
  maximalgroesse von 255 zeichen aus; es
  sollte also eigentlich gross genug sein;

  nicht vergessen: speicher wieder freigeben
*/
char    *path = malloc ( 255 );

/*....*/

void irgendwas (char *path, char *filename)
{
    char   *pathfilename;
    int    path_len = strlen ( path );     
    int    real_filename_len = strlen ( path ) + 1; /*+1 weil '\0'*/

          /*wenn groesse beider zeichenketten zusammen > 255*/
          if ( (path_len + real_filename_len) > 255 )
                  /*versuche speicher mit groesse beider strings zu reallocieren*/
                  if ( !realloc ( path, path_len + real_filename_len ) )
                         return;

          pathfilename = strcat(path,filename);
}

Wenn ich keinen Fehler gemacht habe, sollte das so funktionieren

mfg
v R

virtual

Original erstellt von virtuell Realisticer:
Hi,

ich wuerde es so machen:
[...]
                  if ( !realloc ( path, path_len + real_filename_len ) )
[...]
}
Wenn ich keinen Fehler gemacht habe, sollte das so funktionieren

mfg
v R

Autsch. realloc gibt den Pointer auf den neuen Speicher zurück, der von path wrd ungültig. Auch ein

path =realloc(path,...)

ist ein beliebter Fehler, weil wenn realloc schief geht man dadurch ein Speicherloch erzeugt. Also, besser:

cahr* temp;
temp =realloc(path,...);
if (NULL==temp) { fehler };
path = temp;

[ Dieser Beitrag wurde am 09.05.2003 um 12:02 Uhr von virtual editiert. ]

BugBott

Nee, leider nicht.
Das strcat erzeugt immer noch einen Speicherzugriffsfehler!
Musste auch beim Allokieren ein (char davorschreiben, weil
er sonst gemeckert hatte.
Kann das auch sein das das daran liegt das das in meinem Quelltext
mit Objekten arbeite?
Ich meine, in meiner Klasse FILE_ deklariere ich die Variabele,
und erst im Konstruktor kann ich den Arbeitsspeicher Allokieren!
Macht das was aus?

virtuell Realisticer

Autsch. realloc gibt den Pointer auf den neuen Speicher zurück, der von path wrd
ungültig. Auch ein

Ups, aber war doch klar dass ich was falsch mache *g*

Musste auch beim Allokieren ein (char davorschreiben, weil
er sonst gemeckert hatte.

Dachte eigentlich, dass das implizit gemacht wird...

Ich meine, in meiner Klasse FILE_ deklariere ich die Variabele,
und erst im Konstruktor kann ich den Arbeitsspeicher Allokieren!
Macht das was aus?

Sollte eigentich nicht, denn du wirst die Variable ja erst dann nutzen,
wenn du Speicher fuer dein Objekt erzeugt hast.

Vielleicht zeigst du noch en bissle mehr Code

mfg
v R

BugBott

Ich muss mich ja schon schämen!!!!!!!!!!
Ich hatte path und filename gar keine Werte zugewiesen!
Das ist mir gerade aufgefallen!
Habe jetzt zuerst mal vermutet das daher der Fehler kam.
Hab jetzt erst mal den ursprünglichen Code ohne das Allokieren
depostet!

// file.h

class FILE_ {
 private:
  char *path;
  char *filename
  ...
 public:
  FILE_::FILE_();
  FILE_::~FILE_();
  int FILE_::init(char *, char*);
};

// file.c
#include ...
         ...

FILE_::FILE_()
{
 path = "\0";           <----------------- :-D
 filename = "\0";       <----------------- :-D
 ...
}

int FILE_::init(char *path, char *filename)
{
 char *pathfilename = strcat(path,filename);
 if ((stat(pathfilename,&attribut) == NULL) // attribut ist eine Eigenschaft der Klasse FILE_
 {
  errortext = "stat fehlgeschlagen";
  return 1;
 }
 return 0;
}

Und noch ne saublöde Frage:
Nachdem ich char *path = (char *)malloc(255);
mache.
Kann man dann sowas wie path = "Hallo Welt!\n" machen?
Einfach so als wenn nix gewesen wäre?

So, nun eure Meinung wie ich es machen soll!

Und nun eure Meinung!

BugBott

Zwischendurch mal gefragt:
Kann mir einer sagen, warum das mit nem Debugger "gdb" reibungslos
funktioniert!?

virtuell Realisticer

Kann man dann sowas wie path = "Hallo Welt!\n" machen?

Nein, du machst das dann mittels 'strcpy' oder 'strncpy'.

path = "\0";
filename = "\0";

Aehm, kann mich auch irren, aber sollte das eigentlich _nicht_ funktionieren?
Wenn du das Nullterminierungszeichen zuweisen willst, haett ich das so gemacht:

*path = "\0";
*filename = "\0";

Aber den Speicher wuerde ich im CTor schon reservieren. Sonst rufst du
'init' auf, und fuer 'path' und 'filename' ist immernoch kein Speicher
reserviert. Im DTor dann natuerlich Speicher wieder freigeben.

Kann mir einer sagen, warum das mit nem Debugger "gdb" reibungslos
funktioniert!?

Sollte er eigentlich nicht.

mfg
v R

BugBott

Wenn ich euch richtig verstanden habe, sollte ich das so machen?

In FILE_::FILE_()

class FILE_ {
 private:
  char *fileame;
  strcpy(filename,"teamerling.tar");
  char *path = (char *)malloc(255);
  strcpy(path,"/home/Andreas/");
  ...
  ...
};

In FILE_::init

FILE_::init(char *path, char *filename)

 char *pathfile;
 char *temp;
 int len_path = strlen(path);
 int len_file = strlen(file);
 if ((len_path+len_file) > 255)
 {
  temp = realloc(path,len_path+len_file);
  if (temp == NULL)
  {
   FEHLER
  }
  path = temp;
 }
 pathfilename = strcat(path,filename);
 ...
 ...
}

Hab ich das so richtig verstanden?
Ich bekomm beim Kompilieren folgenden Fehler:
file.c: In method int FILE_::init (char *, char *)': file.c:31: cannot convert \void *' to `char *' in assignment
Die zweite Zeile bezieht sich auf:
temp = realloc(path,len_path+len_file);
Habs dann versucht mit
void *temp;
Aber dann meckert er:
file.c: In method int FILE_::init (char *, char *)': file.c:37: cannot convert \void *' to `char *' in assignment
Wobei sich die zweite Zeile auf:
path = temp;
bezieht!

Shade Of Mine

char *fileame;
strcpy(filename,"teamerling.tar");

bitte beschäftige dich mit zeigern!

filename hat keinen speicher!
lies dir mal n tutoria über zeiger durch: http://pw1.netcom.com/~tjensen/ptr/pointers.htm

virtuell Realisticer

Original erstellt von BugBott:
Wenn ich euch richtig verstanden habe, sollte ich das so machen?

In FILE_::FILE_()
class FILE_ {
 private:
  char *fileame;
  strcpy(filename,"teamerling.tar");
  char *path = (char *)malloc(255);
  strcpy(path,"/home/Andreas/");
  ...
  ...
};

Siehe hierzu beitrag von Shade

In FILE_::init

FILE_::init(char *path, char *filename)

 char *pathfile;
 char *temp;
 int len_path = strlen(path);
 int len_file = strlen(file);

Bei 'len_file' machst du noch ein '+ 1' dahinter, denn strcat schliesst die
neue Zeichenkette mit einem weiteren Zeichen (Nullterminierungszeichen) ab

if ((len_path+len_file) > 255)
 {
  temp = realloc(path,len_path+len_file);
  if (temp == NULL)
  {
   FEHLER
  }
  path = temp;
 }
 pathfilename = strcat(path,filename);
 ...
 ...
}
Hab ich das so richtig verstanden?
Ich bekomm beim Kompilieren folgenden Fehler:
file.c: In method int FILE_::init (char *, char *)': file.c:31: cannot convert \void *' to `char *' in assignment

Wie gesagt, dachte dass das eigentlich implizit passiert, offentsichtlich
nicht, du musst also casten

Die zweite Zeile bezieht sich auf:
temp = realloc(path,len_path+len_file);
Habs dann versucht mit
void *temp;
Aber dann meckert er:
file.c: In method int FILE_::init (char *, char *)': file.c:37: cannot convert \void *' to `char *' in assignment
Wobei sich die zweite Zeile auf:
path = temp;
bezieht!

Klar, hier fehlt natuerlich jetzt der cast

mfg
v R

[ Dieser Beitrag wurde am 09.05.2003 um 20:38 Uhr von virtuell Realisticer editiert. ]

BugBott

Hi Leutz,
habs jetzt endlich hinbekommen!
Hab mir die Doku über Zeiger durchgelesen!
THX4help