Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » Rätselecke » 3. Sonntagsrätsel

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 < [ 2 ]
000
28.07.2002, 02:43 Uhr
virtual
Sexiest Bit alive
(Operator)


Da es mir zu anstrengend ist, immer zwei Rätsel zu machen, mache ich ab jetzt nur eins. Wem die nicht passen, soll einfach selber welche erfinden (NemoEimi machts ja schon vor ).

Aufgabe
Schreibe ein Programm, welches aus C bzw. C++ Sourcecode alle Kommentare entfernen kann. Die Lösung, die am wenigsten Kommas und Semikolons verwendet, möge als die beste gelten .

P.S.: Übrigens, für die ganz schlauen:
Solche Dinger gehen natürlich nicht durch:

Code:
#define REINGELEGT ;
#define AETSCH ,


Weil ich jag den Source einfach durch einen Präprozessor, um die Kommas und Semikolons zu zählen!
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)

Dieser Post wurde am 28.07.2002 um 02:48 Uhr von virtual editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
04.08.2002, 23:16 Uhr
Hans
Library Walker
(Operator)



Zitat:
virtual postete

Aufgabe
Schreibe ein Programm, welches aus C bzw. C++ Sourcecode alle Kommentare entfernen kann. Die Lösung, die am wenigsten Kommas und Semikolons verwendet, möge als die beste gelten .

P.S.: Übrigens, für die ganz schlauen:
Solche Dinger gehen natürlich nicht durch:

Code:
#define REINGELEGT ;
#define AETSCH ,


Weil ich jag den Source einfach durch einen Präprozessor, um die Kommas und Semikolons zu zählen![/i]


Hallo zusammen,

heute ist zwar inzwischen der auf den Tag der Rätslstellung folgende Sonntag, aber bevor hier gar nichts mehr passiert, liefere ich mal sowas wie 'ne Diskussionsgrundlage. Dummerweise ungetested, weil die Dateiverarbeitung bei mir nicht klappt. (Die Gründe sind mir allerdings Schleierhaft.) Deshalb hab ich meine Ideen zum Punkte- und Kommaeinsparen auch erst mal nicht darin umgesetzt, sondern nur die grundsätzliche Idee, wie man Kommentare aus dem Quelltext entfernen kann.


C++:
/* Datei: decommenter.c

   Programm zum entfernen saemtlicher Kommentare aus einem C oder C++ Quelltext
   Es werden Kommentare der Form: /* Kommentar 1 * / und solche der Form
   // Kommentar 2
   beruecksichtigt. Die Klassischen C-Kommentare duerfen auch geschachtelt sein.

   Version 0.1c by HGP
*/


#include <stdio.h>
#include <stdlib.h>
#include <sys\stat.h>


int main(int argc, char *argv[])
{
  long s;
  int flag1=0, flag2=0;
  char ch;
  FILE *in, *out;

  struct stat statbuf;


  if (argc!=3)
     { printf ("\nAufruf: decomm <Name der Eingabedatei> <Name der Ausgabedatei>\n");
       exit (1);
     }

  // if ((in=fopen(*++argv, "r")) == NULL)
    if ((in=fopen(argv[1], "r")) == NULL)
     {
       fprintf(stderr, "Can't open input file: %s\n", argv[1]);
       exit(1);
     }
  // printf ("*argv = %s\n", *argv);

/* Einholen von Informationen über die Datei */
   stat(in, &statbuf);

  // if ((out=fopen(*++argv, "w")) == NULL)
    if ((out=fopen(argv[2], "w")) == NULL)
     {
       fprintf(stderr, "Can't open output file: %s\n", argv[2]);
       exit(1);
     }
  // printf ("*argv = %s\n", *argv);

  s=statbuf.st_size;
  while (s>=0)
      {
         ch=getc(in);
    /* Hier wird überprüft, ob die gerade gelesenen Zeichen zu
       Kommentaren gehören, oder nicht.
       Dementsprechend sind die Flags gesetzt.
    */

    if (flag1)    // flag1 für / * */ - Kommentare
     {
           if (ch == '*')
            {
              if ((ch=getc(in)) == '/')
                { flag1--; continue; }
              else
                { ungetc (ch, in); ch='*'; }
            }
         }
        else continue;

        if (flag2)    // flag2 für Kommentare wie diesen
         {
           if (ch=='\n') flag2--;
           else continue;
         }
        /* Hier wird getestet, ob das gerade gelesene Zeichen einen
           Kommentar einleitet, oder nicht. Entsprechend werden die Flags
           gesetzt, die oben geprüft werden.
        */

        if (ch == '/')
         {
           if ((ch=getc(in)) == '*')
             { flag1++; continue; }
           if (ch == '/')
            { flag2++; continue; }
         }
        /* Das gelesene Zeichen gehört nicht zu Kommentaren, und leitet
           auch keinen ein, d.h. es kann in die Ausgabedatei kopiert werden.
        */

        putc (ch, out);
        s--;
      } /* while-Schleife */

  /* Alle Dateien schliessen */
  fclose (in);
  fclose (out);

  return 0;
} /* main */




Soweit der Quelltext; vielleicht kann mir ja jemand sagen, wo der Fehler steckt, den ich dauernd übersehe...

Hans

P.S. Dieses Listing enthält auch geschachtelte Kommentare!!! Deshalb stimmt die Farbgebung nicht immer!!!
--
Man muss nicht alles wissen, aber man sollte wissen, wo es steht. Zum Beispiel hier: Nachdenkseiten oder Infoportal Globalisierung.

Dieser Post wurde am 04.08.2002 um 23:45 Uhr von Hans editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
04.08.2002, 23:38 Uhr
virtual
Sexiest Bit alive
(Operator)


Ah, endlich jemand der sich traut. Hatte/habe heute leider nicht so viel Zeit gehabt, werde es mir morgen mal anschauen. Dann kommt auch das 4. Sonntagsrästel...
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
05.08.2002, 18:21 Uhr
Uwe
C/C++ Master
(Administrator)


Hallo,
da es mir zeitlich wie virtual geht, hab ich mal einen betr. Thread im "alten" Forum raus gesucht, in welchem NULL zur damaligen Zeit folgendes postete:


C++:
/*
*  replace.c
*  - Ersetzt die Kommentare in einem C/C++ Quelltext durch Leerzeichen.
*
*  This file is
*    Copyright (C) 2001 Franz Fritsche <info@simple-line.de>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2, or (at your option)
*  any later version.
*
*  This program is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software Foundation,
*  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/


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

#define DATEI_ENDE EOF
#define gehe_ueber_in goto


FILE *file_oeffnen(const char *path, const char *mode);
int file_schliessen(FILE *pfile);

inline int lese(char &zeichen);
inline void schreibe(char zeichen);

void pruefe_optionen(int argc, char *argv[]);
void benutzung(void);
void help(void);


FILE *ein, *aus;

int main(int argc, char *argv[])
{
    pruefe_optionen(argc, argv);

    /*--- Files oeffnen ---------------------------------------*/

    ein = file_oeffnen(argv[1], "r");
    aus = file_oeffnen(argv[2], "w");


    /*--- Beginn der eigentlichen Bearbeitung -----------------*/

    char c, d;  /* Fuer die einzulesenden Zeichen */

    gehe_ueber_in Zustand0;


    Zustand0:  /* Zustand0: Lese Source-Text */

    while (lese(c) != DATEI_ENDE)
    {
        switch (c)
        {
            case '\a':
            case '\b':
            case '\f':
            case '\r':
            case '\t':
            case '\v':
                schreibe(' ');
                break;

            case '\\':
                if (lese(d) != DATEI_ENDE)
                {
                    schreibe(c);
                    schreibe(d);
                }
                else /* Dateiende erreicht! */
                {
                    schreibe(c);
                    gehe_ueber_in Endezustand;
                }
                break;
            /* Beginn einer String-Konstante */
            case '"':
                schreibe('"');
                gehe_ueber_in Zustand3;

            case '/':
                if (lese(d) != DATEI_ENDE)
                {
                    switch (d)
                    {
                        case '*':  /* Beginn eines C-Kommentars */
                            schreibe(' ');
                            schreibe(' ');
                            gehe_ueber_in Zustand1;

                        case '/':  /* Beginn eines C++-Kommentars */
                            schreibe(' ');
                            schreibe(' ');
                            gehe_ueber_in Zustand2;

                        default:
                            schreibe(c);
                            schreibe(d);
                    }
                }
                else /* Dateiende erreicht! */
                {
                    schreibe(c);
                    gehe_ueber_in Endezustand;
                }
                break;

            default:
                schreibe(c);
        }
    }
    gehe_ueber_in Endezustand;


    Zustand1:  /* Zustand1: Lese C-Kommentar-Text */

    while (lese(c) != DATEI_ENDE)
    {
        switch (c)
        {
            case '\n':
                schreibe('\n');
                break;

            case '*':
                if (lese(d) != DATEI_ENDE)
                {
                    if (d == '/') /* C-Kommentar ist zu ende */
                    {
                        schreibe(' ');
                        schreibe(' ');
                        gehe_ueber_in Zustand0;
                    }
                    else if (d == '\n')
                    {
                        schreibe(' ');
                        schreibe('\n');
                    }
                    else
                    {
                        schreibe(' ');
                        schreibe(' ');
                    }
                }
                else /* Dateiende erreicht! */
                {
                    schreibe(' ');
                    gehe_ueber_in Endezustand;
                }
                break;

            default:
                schreibe(' ');
        }
    }
    gehe_ueber_in Endezustand;


    Zustand2:  /* Lese C++-Kommentar-Text */

    while (lese(c) != DATEI_ENDE)
    {
        switch (c)
        {
            case '\\':
                if (lese(d) != DATEI_ENDE)
                {
                    if (d == '\n')
                    {
                        schreibe(' ');
                        schreibe('\n');
                    }
                    else
                    {
                        schreibe(' ');
                        schreibe(' ');
                    }
                }
                else /* Dateiende erreicht! */
                {
                    schreibe(' ');
                    gehe_ueber_in Endezustand;
                }
                break;

            case '\n': /* C++-Kommentar ist zu ende */
                schreibe('\n');
                gehe_ueber_in Zustand0;

            default:
                schreibe(' ');
        }
    }
    gehe_ueber_in Endezustand;


    Zustand3:  /* Lese String-Konstante */

    while (lese(c) != DATEI_ENDE)
    {
        switch (c)
        {
            case '\\':
                if (lese(d) != DATEI_ENDE)
                {
                    schreibe(c);
                    schreibe(d);
                }
                else /* Dateiende erreicht! */
                {
                    schreibe(c);
                    gehe_ueber_in Endezustand;
                }
                break;

            case '\"':
                schreibe(c);
                gehe_ueber_in Zustand0;

            default:
                schreibe(c);
        }
    }
    gehe_ueber_in Endezustand;


    Endezustand:
    file_schliessen(ein);
    file_schliessen(aus);

    return 0;
}


FILE *file_oeffnen(const char *path, const char *mode)
{
    FILE *pfile;

    pfile = fopen(path, mode);
    if (pfile == NULL)
    {
        fprintf(stderr, "REPLACE: Fehler: Die Datei %s konnte nicht geoeffnet werden!\n", path);
        exit(EXIT_FAILURE);
    }

    return pfile;
}


int file_schliessen(FILE *pfile)
{
    int result;

    result = fclose(pfile);
    if (result == EOF)
    {
        fprintf(stderr, "REPLACE: Fehler: Eine Datei konnte nicht geschlossen werden!");
        exit(EXIT_FAILURE);
    }

    return 0;
}


inline int lese(char &zeichen)
{
    int temp;

    temp = fgetc(ein);
    zeichen = (char) temp;

    return temp;
}


inline void schreibe(char zeichen)
{
    if (fputc(zeichen, aus) == EOF)
    {
        fprintf(stderr, "REPLACE: Beim Schreiben auf die Zieldatei ist ein Fehler aufgetreten!\n");
        fprintf(stderr, "(Moeglicherweise ist der Datenträger voll?)\n");
        exit(EXIT_FAILURE);
    }
}


void pruefe_optionen(int argc, char *argv[])
{
    if (argc == 1 || argc > 3)
    {
        benutzung();
        exit(EXIT_FAILURE);
    }

    if (argv[1][0] == '/' || argv[1][0] == '-')
    {
        switch (argv[1][1])
        {
            case '?':
                help();
                exit(EXIT_SUCCESS);
            case 'h':
            case 'H':
                if (!strcmp(argv[1]+1,"h") || !strcmp(argv[1]+1,"help")
                 || !strcmp(argv[1]+1,"H") || !strcmp(argv[1]+1,"HELP")
                 || !strcmp(argv[1]+1,"Help"))
                {
                    help();
                    exit(EXIT_SUCCESS);
                }

            default:
                fprintf(stderr,"REPLACE: Ungueltige Option: %s\n",argv[1]);
                exit(EXIT_FAILURE);
        }
    }

    if (argc == 2 || argv[2][0] == '/' || argv[2][0] == '-')
    {
        benutzung();
        exit(EXIT_FAILURE);
    }

    if (!strcmp(argv[1], argv[2]))
    {
        fprintf(stderr,"REPLACE: Fehler: Quelle und Ziel duerfen nicht identisch sein!\n");
        exit(EXIT_FAILURE);
    }
}


void benutzung(void)
{
    fprintf(stderr,"Benutzung: REPLACE [Laufwerk:][Pfad]Quelle [Laufwerk:][Pfad]Ziel\n");
}


void help(void)
{
    fprintf(stderr,"Ersetzt die Kommentare in einem C/C++ Quelltext durch Leerzeichen.\n\n"
  "REPLACE: [Laufwerk:][Pfad]Quelle [Laufwerk:][Pfad]Ziel\n\n\
   Quelle\tDateiname der Quelldatei.\n\
   Ziel  \tDateiname der Zieldatei.\n"
);
}


als Ergänzung noch der Link zum gesamten Thread
http://f22.parsimony.net/forum43115/messages/5344.htm
--
"Es ist schwierig, ein Programm wirklich idiotensicher zu machen, weil Idioten so genial sind."

Bis dann...
Uwe

Dieser Post wurde am 05.08.2002 um 18:33 Uhr von Uwe editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
06.08.2002, 13:07 Uhr
~Christian
Gast


Hallo,

@Uwe
Das ist aber eine hässliche Lösung .. goto?


Deshalb habe ich heute auch eine Lösung geschrieben.
Sie ist warscheinlich auch nicht wunderschön, aber dafür funktioniert sie und ist ohne goto
Punkte und Semikolon's habe ich nicht gezählt...

Here we go:

C++:
/********************************************************************
* Christian May 06.08.02    <christian.may@walux.de>
*
* Programm kann C-Sytle und C++-Style Kommentar
*  aus Quelltexten entfernen.
*
* C-Style Kommentar:        /* ... * /
* C++-Style Kommentar:        // ...
*
* find() gibt -1 zurück, wenn der Suchstring nicht gefunden wird.
* Ansonsten gibt er die stelle zurück an der der Suchstring anfängt.
**/


#include <iostream>
#include <fstream>
#include <string>

int main()
{
    int a        = 0,
        b        = 0,
        c        = 0,
        len        = 0,
        count    = 0;

    bool cstyle    = false;
    char cstr[1000];

    std::string str,
                space;

    std::fstream source,
                 dest;

    source.open("test.cpp", std::ios::in);

    if(source.is_open())
    {
        dest.open("ziel.cpp", std::ios::out);

        if(dest.is_open())
        {
            while(!source.eof())
            {
                // Beim ersten Durchlauf kein Zeilenumbruch in
                //  Zieldatei
                if(count!=0)
                    dest << std::endl;

                // Zeilenzähler
                count++;

                // Aktuelle Zeile bis '\n' auslesen
                source.getline(cstr, 1000, '\n');
                // von char in string kopieren
                str = cstr;

                // Länge der Zeile ermitteln
                len = str.length();

                // Wurde ein C-Style Kommentar noch nicht
                //  geschlossen?
                if(cstyle)
                {
                    // Ist in der aktuellen Zeile ein C-Style
                    //  Kommentar zuende?
                    b = str.find("*/");
                    if(b>0)
                    {
                        // Da find() nur auf den Anfang des
                        //  Kommentarendes Zeigt
                        b += 2;
                        // String mit passenden Leerzeichen füllen
                        for(int i=0; i<b; i++)
                            space += " ";
                        // Leerzeichen an passender stelle einfügen
                        str.replace(0, b, space, 0, b);

                        // Ein Ende wurde gefunden
                        cstyle = false;
                    }
                    else
                    {
                        // In der aktuellen Zeile wurde kein Ende
                        //  gefunden. Daher muss die ganze Zeile
                        // Leerzeichen ersetzt werden.

                        // String mit passenden Leerzeichen füllen
                        for(int i=0; i<len; i++)
                            space += " ";
                        // Leerzeichen einfügen
                        str.replace(1, len, space, 1, len);
                    }
                }
                else
                {
                    // Ist in der aktuellen Zeile ein C-Style
                    //  Kommentar Anfang?
                    a    = str.find("/*");
                    if(a>0)
                    {
                        // Ist in aktueller Zeile auch das Ende?
                        b = str.find("*/
"
);
                        if(b>0)
                        {
                            c = (b+2)-(a);
                            a--;
                            c=c+2;
                            for(int i=0; i<c; i++)
                                space += " ";
                            // Leerzeichen an passender stelle einfügen
                            str.replace(a, c, space, 0, c);
                        }
                        else
                        {
                            // In aktueller Zeile wurde nur ein Anfang
                            //  gefunden, daher muss der Rest der Zeile
                            //  durch Leerzeichen ersetz werden und
                            //  weiterhin muss nach einem Ende gesucht
                            //  werden. Daher "cstyle=true" ...

                            cstyle = true;

                            c = len-a;
                            for(int i=0; i<c; i++)
                                space += " ";
                            str.replace(a, c, space, 0, c);
                        }
                    }
                }

                // Wird in der aktuellen Zeile ein C++-Style
                //  Kommentar gefunden?
                a    = str.find("//");
                if(a>0)
                {
                    c = len-a;
                    for(int i=0; i<c; i++)
                        space += "
";
                    // Leerzeichen an passender stelle einfügen
                    str.replace(a, c, space, 0, c);
                }

                // Zeile in Zieldatei schreiben
                dest << str;

                // String leeren
                str.erase();
                // String mit Leerzeichen leeren
                space.erase();
            }
            dest.close();
        }
        else
            std::cout << "
whoops - cant create destination file!"
                      << std::endl;
        source.close();
    }
    else
        std::cout << "
whoops - is there a source file?"
                  << std::endl;
    return 0;
}


Ich hoffe da kommt von euch ein Feedback ;-)
Kontruktive Kritik ist erwünscht!

Gruß aus Bonn,
Christian
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
06.08.2002, 13:22 Uhr
~Christian
Gast


Ich weis zwar nicht warum, aber anscheinend gab es hier ein Formatierungsproblem...


C++:
a    = str.find("|%|C|%|");


sollte sein:

C++:
a = str.find("//");



und

C++:
a = str.find("|%|LC|%|                if(a>0)
{
                    c = len-a;
                    for(int i=0; i<c; i++)
                        space += "
";
                    |%|LC|%|                    str.replace(a, c, space, 0, c);
                }

                |%|LC|%|                dest << str;

                |%|LC|%|                str.erase();
                |%|LC|%|                space.erase();
            }


sollte sein:

C++:
// Wird in der aktuellen Zeile ein C++-Style
//  Kommentar gefunden?
a = str.find ( "//" );
if(a>0)
{
  c = len-a;
  for(int i=0; i<c; i++)
  space += "
";
  
  // Leerzeichen an passender stelle einfügen
  str.replace(a, c, space, 0, c);
}

// Zeile in Zieldatei schreiben
dest << str;
// String leeren
str.erase();
// String mit Leerzeichen leeren
space.erase();




Naja, wer weis ob das jetzt nicht wieder so ein Müll gibt. Von daher habe ich ihn online gestellt.
http://walux.de/dCom.txt

Gruß,
Christian
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
06.08.2002, 17:30 Uhr
Uwe
C/C++ Master
(Administrator)


Hallo Christian,

Zitat:
~Christian postete
@Uwe
Das ist aber eine hässliche Lösung .. goto?


Hab auch nicht behauptet das sie schön ist Außerdem wie bereits geschrieben nicht von mir.
--
"Es ist schwierig, ein Programm wirklich idiotensicher zu machen, weil Idioten so genial sind."

Bis dann...
Uwe
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
09.08.2002, 13:16 Uhr
virtual
Sexiest Bit alive
(Operator)


Hi,

ich möchte Euchnnicht meine Lösung vorenthalten:


C++:
#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>
#include <iterator>

enum { CODE, CPPCOMMENT, CCOMMENT, STRINGLITERAL, CHARLITERAL };

int main(
    int argc,
    char** argv)
{
    //
    // Check arguments
    //
    if (argc!=3)
    {
        std::cerr << "usage: " << argv[0] << " in out" << std::endl;
        return 1;
    }

    //
    // Read in file
    //
    std::ifstream streamIn(argv[1]);
    std::string strFile;

    std::copy(std::istreambuf_iterator<char>(streamIn),
              std::istreambuf_iterator<char>(),
              std::back_inserter(strFile));
    
    //
    // Walk through file, strip comments
    //
    std::string strStripped;
    const char* begin = strFile.c_str();
    const char* ptr;
    int nMode = CODE;    
    for(ptr = begin; *ptr; ++ptr)
    {
        if (ptr[1] == '\\')
        {
            ++ptr;
            continue;
        }

        switch (nMode)
        {
        case CODE:
            switch (*ptr)
            {
            case '\'':
            case '\"':
                nMode = *ptr=='\''? CHARLITERAL:STRINGLITERAL;
                break;
            case '/':
                if (ptr[1] == '/' || ptr[1] == '*')
                {
                    nMode = ptr[1]=='/'? CPPCOMMENT:CCOMMENT;
                    if (begin!=ptr)
                    {
                        strStripped += std::string(begin, (ptr++)-begin);
                        begin = ptr;
                    }
                }
                break;
            }
            break;
        case CPPCOMMENT:
            if (*ptr=='\n')
            {
                begin = ptr++;
                nMode = CODE;
            }
            break;
        case CCOMMENT:
            if (*ptr=='*' && ptr[1]=='/')
            {
                begin = ptr += 2;
                nMode = CODE;
            }
            break;
        case STRINGLITERAL:
        case CHARLITERAL:
            if ((nMode==STRINGLITERAL? '\"':'\'') == *ptr)
            {
                nMode = CODE;
            }
            break;
        }
    }
    if (begin!=ptr)    
    {            
        strStripped += std::string(begin, ptr-begin);
    }

    //
    //    Output file
    //
    std::ofstream streamOut(argv[2]);
    streamOut << strStripped;
    
    return 0;
}


Ich werde noch die verschiedenen Lösungen miteinander vergleichen, hinsichtlich der Rästelregeln.

@Hans
Bei deinem Programm hatte ich Probleme. Also: Wenn du auch nur halbwegs portabel bleiben willst, dann schreibe in den Includeanweisung nie einen Backslash, sondern stets einen Slash. Das stat erwartet kein Filehandle, sondern einen filenamen. Jedenfalls aber ist stat kein ANSI.
Irgendwiehängt das Programm bei mir. KA, hab es nicht weiter analysiert
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
09.08.2002, 20:55 Uhr
Hans
Library Walker
(Operator)



Zitat:
virtual postete
Hi,

@Hans
Bei deinem Programm hatte ich Probleme. Also: Wenn du auch nur halbwegs portabel bleiben willst, dann schreibe in den Includeanweisung nie einen Backslash, sondern stets einen Slash. Das stat erwartet kein Filehandle, sondern einen filenamen. Jedenfalls aber ist stat kein ANSI.



Hi virtual,

ich weis, das stat eine UNIX-spezifische Angelegenheit ist, das steht in der Beschreibung auch dabei. Ich wollte es erst auch gar nicht verwenden, hab es dann aber damit versucht, weil die Abfrage auf EOF die Schleife sofort beendet hat. D.h. das Prgramm hat gar nichts gelesen, sondern nur eine leere Ausgabedatei erzeugt. (Die Urversion des Programms sieht so aus, wie das Kopierprogramm, wegen dem ich mich ein paar Tage vorher erkundigt habe.)


Zitat:

Irgendwiehängt das Programm bei mir. KA, hab es nicht weiter analysiert



Das tut es bei mir auch, ich weis aber auch nicht warum.

Hans
--
Man muss nicht alles wissen, aber man sollte wissen, wo es steht. Zum Beispiel hier: Nachdenkseiten oder Infoportal Globalisierung.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
009
09.08.2002, 22:01 Uhr
virtual
Sexiest Bit alive
(Operator)


@Hans
Also ein Problem ist mit Sicherheit, dass du in der Schleife ein ungetc machst, aber dabei nicht s hochzaehlst.
Die sache mit dem EOF sollte schon tun. Allerdings darfst du dann ch nicht als char deklarieren, sondern musst ein int nehmen.

@cristian
Dein Programm hat auf jeden Fall schon mal einige Stilpunkte gewonnen, weil gut kommentiert. Übrigens: Grüße aus Bonn, auch von mir
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 < [ 2 ]     [ Rätselecke ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: