3. sieht so professioneller code aus???

sieht so professioneller code aus???

  • J

    ich hab mir mal die sgi stl angeschaut besonders algorithm weil ich mir den ein oder anderen trick abschauen wollte. als ich aber den code gesehen hab bin ich erstmal erschrocken. programmiert man so wirklich professionell? ich habe unheimlich mühe den code zu lesen und bin mehr damit beschäftigt zusammengehörige klammern zu suchen als etwas zu verstehen. bsp:

    template <class _RandomAccessIter>
void __final_insertion_sort(_RandomAccessIter __first, 
                            _RandomAccessIter __last) {
  if (__last - __first > __stl_threshold) {
    __insertion_sort(__first, __first + __stl_threshold);
    __unguarded_insertion_sort(__first + __stl_threshold, __last);
  }
  else
    __insertion_sort(__first, __last);
}

    besonders die unterstriche vor den variablennamen machen mich wahnsinnig...

    0
  • H

    besonders die unterstriche vor den variablennamen machen mich wahnsinnig...

    Jo geht mir genauso 😉

    Wenn überhaupt programmieren nur Compilerbauer und Standard-Library-Schreiber (oder besser Leute die Code für eine bestimmte Implementation schreiben) so, da dies die einzigen sind, die zwei Unterstriche vor einem Namen verwenden dürfen (bzw. einen Unterstrich vor einem globalen Namen).

    0
  • J

    aber zum beispiel was ich auch schon in der beben2 source gesehen hab sind diese funktionsaufrufe bzw. funktionskopfdeclarationen in der art:

    void meine_krasse_funktion(int zahl,
                           char zeichen,
                           float *pointer){
pointer = mach_trallala(zeichen,
                        zahl);
}

    find ich unheimlich unschön... warummacht man das. macht meiner meiung nur sinn wenn man eewig lange parameterlisten hat

    0
  • D

    wenn ich unhemilich lange funktionsaufrufe hab, mach ich so

    funktion (meistens winapi) (x1, x2, x3, x4,
    x5, x6, x7, x8)

    0
  • G
     

    void meine_krasse_funktion(  int      zahl,
                             char     zeichen,
                             float *  pointer)
{
    pointer = mach_trallala(zeichen, zahl);
}

    ich mache da noch zusätzlich tabs rein und es sieht zwar heslig aus aber was soll man machen?
    grösseren bildschirm kaufen? horizontal scrollen kommt nicht in frage
    ich selber schreibe natürlich klassen und verteile die parameter auf methoden oder ähnliche technicken
    z.b. ein klasse schreiben die die parameter zusammenfast

    0
  • O

    Hi.

    Original erstellt von japro:
    **ich hab mir mal die sgi stl angeschaut besonders algorithm weil ich mir den ein oder anderen trick abschauen wollte. als ich aber den code gesehen hab bin ich erstmal erschrocken. programmiert man so wirklich professionell? ich habe unheimlich mühe den code zu lesen und bin mehr damit beschäftigt zusammengehörige klammern zu suchen als etwas zu verstehen. bsp:

    template <class _RandomAccessIter>
void __final_insertion_sort(_RandomAccessIter __first, 
                            _RandomAccessIter __last) {
  if (__last - __first > __stl_threshold) {
    __insertion_sort(__first, __first + __stl_threshold);
    __unguarded_insertion_sort(__first + __stl_threshold, __last);
  }
  else
    __insertion_sort(__first, __last);
}

    besonders die unterstriche vor den variablennamen machen mich wahnsinnig...**

    Bei den Unterstrichen geh ich mit, der Rest ist eigentlich gut lesbar.
    Anstatt die einzelnen Klamern zu suchen, solltest du dir mal die Einrückung ansehen :), die sind nicht umsonst da und du erkennst sofort, welche Anweisungen je nach Bedingung durchlaufen werden.

    Du hast da ein realtiv übersichtliches Gebilde herausgesucht.
    Ich habe da schon wesentlich schlimmere gesehen (bedenke, ich sehe sonst nur Objectpascal-Code, da ist unübersichtlicher Code fast unmöglich 🙂 ).

    MfG other.

    [ Dieser Beitrag wurde am 04.07.2002 um 22:31 Uhr von other editiert. ]

    0
  • ?

    Als Hobby-Programmierer und 12%-Informatiker (2.Semester) frage ich mich auch oft wie profesioneller Code auszusehen hat.
    Oftmals verschwende ich Stunden damit eine optimale Objektorientierte Lösung zu finden. Umso frustrierender wenn man am nächsten Tag Code von Profis liest (sei es in nem Buch oder hier) und feststellt, dass es eine weitaus einfacherer und sauberere Lösung gibt.

    Auf der anderen Seite verwundert mich der Programmierstil von so manchen Gurus auch hin und wieder. Man schaue sich nur mal den Code von John Carmack an. Sowas von unübersichtlich und undurchschaubar...
    Und trotzdem sind seine Programme (Spiele) Referenzprodukte in allen Belangen.

    Das wirft die Frage auf was wichtiger ist: Guter Programmierstil oder das Resultat ?

    0
  • S

    Original erstellt von Space^qx:
    Das wirft die Frage auf was wichtiger ist: Guter Programmierstil oder das Resultat ?

    Kann man nicht sagen. Zuerst zaehlt natuerlich mal das resultat! Aber dann kommt auch gleich dahinter schon die wartbarkeit vom Code und das geht nur bei einem ordentlichen Programmierstil.

    Ich habe noch keine Source von Carmack gesehen, aber die 'Gurus' von denen ich source gesehen haben, von denen schauts immer gut aus 🙂

    0
  • R

    Hi,

    Japros Beispiel kann man noch gut lesen, aber das hab ich mal aus der STL-Implementierung des MSVC6
    kopiert :

    template<class _RI, class _Ty> inline
    void _Sort_0(_RI _F, _RI _L, _Ty *)
    {if (_L - _F <= _SORT_MAX)
        _Insertion_sort(_F, _L);
    else
        {_Sort(_F, _L, (_Ty *)0);
        _Insertion_sort(_F, _F + _SORT_MAX);
        for (_F += _SORT_MAX; _F != _L; ++_F)
            _Unguarded_insert(_F, _Ty(*_F)); }}
template<class _BI, class _Pr> inline
    _BI partition(_BI _F, _BI _L, _Pr _P)
    {for (; ; ++_F)
        {for (; _F != _L && _P(*_F); ++_F)
            ;
        if (_F == _L)
            break;
        for (; _F != --_L && !_P(*_L); )
            ;
        if (_F == _L)
            break;
        iter_swap(_F, _L); }
    return (_F); }

    Und das geht seitenweise so.
    Oder sowas :

    template<class _RI, class _Pd, class _Ty> inline
    void _Rotate(_RI _F, _RI _M, _RI _L, _Pd *, _Ty *)
    {_Pd _D = _M - _F;
    _Pd _N = _L - _F;
    for (_Pd _I = _D; _I != 0; )
        {_Pd _J = _N % _I;
        _N = _I, _I = _J; }
    if (_N < _L - _F)
        for (; 0 < _N; --_N)
            {_RI _X = _F + _N;
            _RI _Y = _X;
            _Ty _V = *_X;
            _RI _Z = _Y + _D == _L ? _F : _Y + _D;
            while (_Z != _X)
                {*_Y = *_Z;
                _Y = _Z;
                _Z = _D < _L - _Z ? _Z + _D
                    : _F + (_D - (_L - _Z)); }
            *_Y = _V; }}

    Alles hinter solchen unverständlichen Namen verborgen, und dabei lese ich überall man solle doch aussagekräftige Namen vergeben, ja die Namen der Funktionen klingen gut ( random_shuffle, sort, remove_if,
    for_each ), aber der Implementierungscode sieht echt nur noch verwirrend aus.
    Also wenn so professioneller Code aussieht / aussehen soll dann hoffe ich nur keinen Job als Programmierer
    zu bekommen.

    [ Dieser Beitrag wurde am 05.07.2002 um 02:24 Uhr von Real_PsychoDAD editiert. ]

    0
  • T

    ich gestehe. ich verwende auch hin und wieder den hässlichen "_" aber im momentanen project nur bei classen namen und den dazugehörigen dateinahmen. ein kleines beispiel:

    class DLL_Manager ; ist z.b die managerklasse aus dem programmpacket DLL ( hir auch als DLL implementiert )

    oder

    class IF_Manager ; ist auch eine managerklasse nur aus dem programmpacket IF ( IF steht bei mir für InterFace, damals nichts besseres eingefallen. diese klassen sind alle abstrackt und dienen wie gesagt nur als interface)

    meist leg ich auch noch für jede klasse nen typedef für den Pointer an

    typdef DLL_Manager* p_DLL_Manager;

    ich weiss zwar nicht ob das leserlich ist. ich weis zumindestens was was ist und wie ich das zu deuten habe.

    gruss termite

    0
  • J

    Original erstellt von Termite:
    **
    typdef DLL_Manager* p_DLL_Manager;
    **

    die _ in den namen drinn stören mich überhaupt nicht. so nenne ich z.b. alle meine eigenen typen in der art nummer_t, meintyp_t etc.
    aber die vorangestellten find ich grässlich besonders wenn man dann sowas sieht:
    --__a;

    0
  • V

    @japro
    Was noch dazu kommt: Mit doppelten Underscores oder Aehnlichem solltest Du auch gar nix machen. Aus dem Standard:
    17:4.3.1.2:

    [...]- Each name that contains a double underscore (__) or begins with an underscore followes by an uppercase letter is reserved to the implementation for any use.
    - Each name that begins with an underscore is reserved to the implementation for use as a name in the global namespace. Such names are also reserved in Namespace ::std.

    0
  • H

    @virtual
    Das ist tatsächlich eindeutig besser formuliert als mein umgangssprachliches Geholpere 🙂

    0
  • K

    Ich schätz mal, dass da sogar ein bisschen Absicht dahintersteckt, wenn die stl möglichst unleserlich geproggt ist. Es tut den Firmen wahrscheinlich sowieso schon weh, dass sie wegen dem Template-Zeugs den kompletten Quellcode mitliefern müssen ...

    0
  • S

    @kartoffelsack: Ich wollte mir mal die Stream-Bibliothek der MSVC-Libary näher ansehen - damals wollte ich eine eigene bauen. Nur leider kann man da überhaupt nix erkennen. Da werden nur einbuchstabrige Variablen hin und her geschaukelt, und alles endet irgendwo in einem Header mit einem 'x' am Anfang :(.

    MfG SideWinder

    0
  • G

    wahrscheinlich haben die eine art parser der das so unläserlich macht

    [ Dieser Beitrag wurde am 05.07.2002 um 11:46 Uhr von Dimah editiert. ]

    0
  • ?

    ich denke mal die stl implementeure wussten nicht genau was sie machen und haben deshalb eben so dummy variablen genommen, weil sie den eigentlichen sinn der variable nicht verstanden haben

    0
  • V

    @dimah
    du meinst vermutlich sowas wie cfog, zu finden z.B. hier:
    http://www.norfolk.navy.mil/oasys/c/files.html
    Die machen IHMO aber richtig krassen output.

    @iknow
    Also IMHO wissen die Jungs und Mädels schon sehr genau, was sie so machen. Meistens jedenfalls. 😉

    0
  • G

    Original erstellt von virtual:
    **@dimah
    du meinst vermutlich sowas wie cfog, zu finden z.B. hier:
    http://www.norfolk.navy.mil/oasys/c/files.html
    Die machen IHMO aber richtig krassen output.
    **

    heist das das der code noch schlimmer aussehen würde wenn sie ihn durch solch ein paser laufen lassen würden? oder hatten die nicht so viel zeit ein guten zu schreiben? oder es gibt menschen die wirklich so progen 😮 vieleicht sehen sie es als cool an 😕 zum glück denke ich genau anders rum

    0
  • V

    @dimah
    Aus dem Manual von dem Teil

    o uses your system's C preprocessor to incorporate the contents of include files into the source file and execute all preprocessor directives. By default, FOG only processes local include files and does not process system include files.

    o replaces all identifier names (including function names) with a generic style of name--by default this is i_dn where n is a number that is different for every unique identifier.

    o "octalizes" strings. The characters in all character strings in the file (e.g., those in printf statements) are replaced with their octal equivalents; i.e., "hello world" becomes "\150\145\154\154\157\40\167\157\162\154\144".

    o removes comments.

    o removes the physical structure of the program.

    Eben alles, was das Herz begehrt. 😉

    0
Anmelden zum Antworten