Thema: "Naming Conventions" (mein Tip!)

[rapso]

Reyx schrieb:

Es ergibt sich aus den Zusammenhang (den ein reales Projekt im Gegensatz zu so einem eingestreuten Code-Snippet haben sollte); falls nicht, sollte man in Erwägung ziehen, sein Design etwas zu überdenken. Andererseits: Womit arbeitet ihr? Vim? Solch ein Codekonstrukt kommt nicht wirklich häufig vor, und falls doch, wird einem jede moderne IDE sehr schnell helfen, herauszufinden, woran man ist.

wenn man sich einen fremden/alten source anschaut, hat man nicht sofort überblick über das ganze projekt. dafür sind styleguids da, damit man sich nicht durch verschiedene sourcestücke hangeln muss um eine Var deuten zu können. wenn jemand nur für sich codet, weiß er wahrscheinlich woran er bei den benennungen ist.

Reyx schrieb:

rapso schrieb:

Reyx schrieb:

"C" für Klassen halte ich für idiotisch

es ist ebenfalls idiotisch andere vorlieben als idiotisch zu bezeichnen.

Idiotisch ist es tatsächlich, andere Vorlieben als idiotisch zu bezeichnen; daher habe ich auch wohl überlegt die Phrase "halte ich" hinzugefügt, um meine persönliche, unverbindliche Meinung darzustellen! Ich habe da keine Kritik an irgendwelchen Vorlieben genommen, sondern lediglich die Methode verurteilt! Was du daraus machst, ist dein Ding!

ändert leider nichts daran, dass du die vorlieben der anderen als idiotisch betitelst.

Reyx schrieb:

rapso schrieb:

Reyx schrieb:

denn wenn ich die Klasse schon benutze, dann weiß ich auch, dass es eine ist.

es ist auch für den moment, bei denen man nicht weiß was es ist.

Auch ein Unding, welches mit einer guten IDE Geschichte ist.

und mit einer guten styleguid nie vorhanden ist/war.

Reyx schrieb:

rapso schrieb:

wäre

NULLPOINTER

ein enum, const irgendwas oder ein #define

Auch ein Unding, welches mit einer guten IDE Geschichte ist.

und ebenfals mit einer guten styleguid nie in frage stünde.

Reyx schrieb:

klar kann man sich mit tausenden helferlein jede ordnung ersparen, man könnte kennzeichen auch nur durchnummerieren ohne jeglichen zusammenhang zur vergabestelle, trotzdem gibt es eine für menschen ohne hilfsmittel lesbare bezeichnungen, die dir unabhängig von den verwendeten tools aufschluss geben.

Ordnung ist subjektiv, was du machst, mag für dich in Ordnung sein, meiner Meinung nach ist es das schon lange nicht mehr. Künstliches verunstalten der Namen, gezieltes Aushebeln der Refactoring-Möglichkeiten und letzlich doch nicht bessere Software. In einer guten Umgebung mit guter Struktur und einem guten Programmierer entstehen all die Dinge, denen ihr mit euren Namenkonventionen entgegenwirken wollt, erst gar nicht! So zumindest meine Meinung.

ja, da stimm ich dir zu, ein einzelner programmierer an einem projekt kann arbeiten wie er will und ob mit oder ohne styleguid wird wohl fast dasselbe rauskommen(nein, das ist keine ironie, da stimm ich dir ehrlich zu, ich selbst hatte auch keine styleguide bevor ich in einer firma arbeitete und kamm auch nie auf den gedanken ich hätte sowas gebraucht). in einer umgebung mit 50programmierern kann man jedoch nicht erwarten, dass alle ein überblick über das ganze projekt und jedes detail davon haben. menschen sind nunmal so gemacht, dass sie daten besser verarbeiten, wenn sie ihnen besser presentiert werden. dafür sind dann styleguids, und auch um trivialfehler auszuschliessen. einige c++ konstrukte wie const oder explicit könnte man theoretisch auch sein lassen und davon ausgehen dass jeder weiß worum es dabei geht, aber diese nur zum vermeiden menschlicher fehler existierenden dinge sind schon in dem standard. und darauf zielt unsere styleguide auch ab,sie schreibt z.b. vor, dass vergleichsoperationen die constanten linksstehend haben (entnommen aus einer IBM styleguid bei der ein if(blabla=true)... einen folgeschweren/kostenintenstiven fehler verursachte).

Reyx schrieb:

rapso schrieb:

Reyx schrieb:

Ich schreibe ja auch nicht "Auto::autoReifen" oder "Auto::memberAutoReifen". Wo würde man da denn auch hin kommen!? (Auto::memberAutoReifen::membersMemberAutoReifenProfil::membersMembersMemberAutoReifenProfilTiefe::membersMembersMembersMemberAutoReifenProfilTiefeSet(5))

klar, echte helden können ohne namespaces und namenskonventionen auskommen, wozu denn auch?

Keine Stellungname zu meinem Post, keine plausible Erklärung, keine erkennbaren Bezugspunkte; sorry, dass kann ich nicht verarbeiten.

sollte eine anspielung darauf sein, dass es leute gibt, die absolut keine namespaces nutzen wollen oder alles nur in ihrem namesspace schreiben. klar geht auch, unsere styleguid schreibt da was anderes vor, aber ein programm läuft ohne namespaces genau so gut und ein programmierer kann seinen source überblicken ohne dass er ihn in namespaces eintaucht... für anderer wären namespaces aber hilfreich.

Dass ist Namenskonventionen für sinvoll halte, sollte bereits aus meinem ersten Post im Thread hier ersichtlich sein, nur die Art, wie manche Leute das Differenzieren, gibt mir zu Denken übrig.

wir haben bei uns in der firma auch einige dinge aus der styleguid rausgenommen, z.b. float fValue; unsigned int uiCount; weil diese prefixe unnötig sind, spätestens wenn ein warning vom compiler rauskommt, weiß man dass man falsch lag :).
gut finde ich hingegen, dass man sich auf Size für bytegrößen und Count für festlegt, sonst gab es manchmal klassen in denen Size(),Count() und Number() den selben wert zurücklieferte, weil jeder für "seinen" code was anderes annahm, bzw gesucht hatte. das zeigt nur, dass jeder sicherlich einen guten code schreiben könnte, aber gemeinsamm braucht man eben solche protokolle zur zusammenarbeit.

[rapso]

otze schrieb:

rapso schrieb:

@otze, ok war ein blödes beispiel, nimm

void CFoo::Init(int Size)
{
   m_Size=Size;
}

void Foo::init(int size)
{
   this->size=size;
}

einzige stelle bei der ich bei meiner naming convention this-> benutze

klar ist ne möglichkeit, die lösung an sich find ich auch ok. ich bin aber gegen dieses this->, weil es n00bs, die sich mal mit so nem code auseinander setzen auf die idee bringt, man sollte immer this-> für member verwenden und daraus entsteht dann ein recht grausiger code. ich frage mich aber wie du dann accessorfunktionen schreibst, sowas wie:

class CFoo
{
void* data;
...

public:

    void* data(){return this->data;}
}

dürfte doch nicht compilieren? mir würden da spontan nur set/get funktionen aus c zeiten einfallen
klär mich auf

[rapso]

1310-Logik schrieb:

warum nicht gleich so?

//ctor
Foo(unsigned int size_):
size(size_)
{
}

Den Paramter braucht man ja weniger oft als die Membervariable.

weil jemand später mal auf die idee kommen könnte, dass man noch parameter dazubaut

print(char* pStr);

..hah, schaut unsicher aus

print(char* pStr,int size);

phu, das schaut nun sicher aus
dabei würde er, falls es ein size gab, size überschreiben und falls das verwendet wurde, wäre die funktion im A...

oder meinst du grundsätzlich _ als postfix für alle parameter?

[volkard]

rapso schrieb:

...

das tut mit weh.

[rapso]

volkard schrieb:

rapso schrieb:

...

das tut mit weh.

du tust mit auch öfter weh.

[volkard]

1310-Logik schrieb:

warum nicht gleich so?

//ctor
Foo(unsigned int size_):
size(size_)
{
}

Den Paramter braucht man ja weniger oft als die Membervariable.

das mach ich seit jahren so. den bedarf dafür gibts übrigend *nur* nur bei konstruktoren, also ausreichend selten.

[otze]

rapso schrieb:

klar ist ne möglichkeit, die lösung an sich find ich auch ok. ich bin aber gegen dieses this->, weil es n00bs, die sich mal mit so nem code auseinander setzen auf die idee bringt, man sollte immer this-> für member verwenden und daraus entsteht dann ein recht grausiger code.

dann muss man diesen n00bs erklären, dass man this-> nur in ganz wenigen spezialfällen benutzt, und auch nur wnen man weis, was man tut!

ich frage mich aber wie du dann accessorfunktionen schreibst, sowas wie:

class CFoo
{
void* data;
...

public:

    void* data(){return this->data;}
}

dürfte doch nicht compilieren? mir würden da spontan nur set/get funktionen aus c zeiten einfallen
klär mich auf

ich benutze eigentlich auch noch die guten alten set/get funktionen
sie sagen genug aus, und man kann wenig mit falsch machen. Im moment überleg ich mir aber, davon weg zu gehen und properties zu nutzen.

[rüdiger]

@rapso
Eure Namenskonventionen sehen mir eher danach aus, als wollte man eher die Fehler eines uneinheitlichen Programmierstil reduzieren wollen.

Ich benutze eigentlich sehr wenige POD-structs. Die die ich benutze sind in der Regel ziemlich lokal angesiedelt oder es ist eindeutig zu verstehen das es sich um simple Datensammlungen handelt. Daher würde ich bei einem ImageDescriptor kein zweites mal nachdenken und sofort von einer Klasse ausgehen. Aber selbst wenn das alles nicht der Fall ist, so verrät mir ein CImageDescriptor oder ein SImageDescriptor immer noch nicht wie ich die Klasse oder POD-struct benutze.

Oder kannst du mir nun sagen, wie erzeuge ich ein CImageDescriptor oder ein SImageDescriptor? Da ist man eh auf die Dokumentation, ein Blick in den Code oder die IDE angewiesen. Warum benötige ich dann also ein extra C oder S?

Bei den Konstanten seh ich das ähnlich, im Zweifelsfall müsste ich ja erst nachgucken, weil ich nicht weiß ob EVENTS_N nun ein enum oder ein int const ist und so also eEVENTS_N oder cEVENTS_N heißt. Da sehe ich keinen großen Mehrwert. Ich würde eher sagen nur const benutzen (#define sollte man ja eh nicht benutzen) oä.

[rapso]

otze schrieb:

dann muss man diesen n00bs erklären, dass man this-> nur in ganz wenigen spezialfällen benutzt, und auch nur wnen man weis, was man tut!

klingt als hättest du das noch nie machen müssen, ich hab das am WE stunden dazu verbracht...

otze schrieb:

ich benutze eigentlich auch noch die guten alten set/get funktionen
sie sagen genug aus, und man kann wenig mit falsch machen. Im moment überleg ich mir aber, davon weg zu gehen und properties zu nutzen.

meinst damit c#?

im prinzip tauscht du m_ gegen get/set, ich würde das nicht als besser ansehen;)

[rapso]

kingruedi schrieb:

@rapso
Eure Namenskonventionen sehen mir eher danach aus, als wollte man eher die Fehler eines uneinheitlichen Programmierstil reduzieren wollen.

eher als was?
ich denke genau dazu ist unsere styleguide da, sicherlich nicht dazu um programmierer zu unnötigen dingen zu nötigen. deswegen haben wir auch einige dinge rausgenommen gehabt. die styleguide wurde auch gefreezt und auch wenn sie nicht perfekt ist, werden keine ewiglangen diskussionen mehr geführt, sondern man hällt sich daran damit code konstant lesbar bleibt.

Ich benutze eigentlich sehr wenige POD-structs. Die die ich benutze sind in der Regel ziemlich lokal angesiedelt oder es ist eindeutig zu verstehen das es sich um simple Datensammlungen handelt. Daher würde ich bei einem ImageDescriptor kein zweites mal nachdenken und sofort von einer Klasse ausgehen.

ich nutze structs auch sehr selten, eigentlich fast nur für gemappte resourcen und als initialisierungskonstrukte für factories... aber wie du schon sagst, würdest du darüber nachdenken was ImageDescriptor ist, bei 50leuten die nachdenken, kann es passieren, dass einer was anderes denkt, das ist menschlich.

Aber selbst wenn das alles nicht der Fall ist, so verrät mir ein CImageDescriptor oder ein SImageDescriptor immer noch nicht wie ich die Klasse oder POD-struct benutze.

nein, die benutzung wird dadurch nicht geklärt, da kommt man über gedocte interfaces/header nicht hinweg. aber wenn du einen source liest, weißt du eher was das zu bedeuten hat. aber auf der anderen seite, wenn du im source

apData

siehst, weißt du dass die resource freigegeben wird, bei pData könntest du ein memoryleak oder sogar ne accessviolation bedenken müssen, wenn du das nutzt. einen änlichen unterschied hast du ja bei param-by-reference und param-by-pointer auch. eine funktion die einen pointer annimt MUSS es handlen können dass es ein NullPointer sein kann den sie bekommt. eine die eine reference will, da mußt du dich drum kümmern, dass du sie sauber fütterst. fütterst du eine die einen pointer erwartet, darfst du sie nicht mit "new CFoo" füttern, eine mit nem autopointer/smartpointer/refcountpointer (je nach festlegung) kümmert sich selber um die daten auf die der pointer zeigt.

Oder kannst du mir nun sagen, wie erzeuge ich ein CImageDescriptor oder ein SImageDescriptor? Da ist man eh auf die Dokumentation, ein Blick in den Code oder die IDE angewiesen. Warum benötige ich dann also ein extra C oder S?

ich kann dir sagen, dass du einen SImageDescriptor so erzeugst:
SImageDescriptor Desc;
ich kann dir sagen, dass du ein CImageDescriptor vermutlich über einen konstruktor erzeugst der eventuell parameter braucht (SImageD... hat keine funktionen und ctors)
ich kann dir sagen, dass du ein IImageDescriptor nicht erzeugen könntest, sondern von einer factory erzeugen müßtest, auch deleten könntest du es nicht selbst und müßtest das über die factory machen (oder es gibt ein refcounting, dann würdest du aber einen CAPImadeDescriptor nutzen, der sich um alles kümmert.

das weiß ich alles nur aufgrund des namens ohne dass es die objekt-deklaration überhaupt gibt

Bei den Konstanten seh ich das ähnlich, im Zweifelsfall müsste ich ja erst nachgucken, weil ich nicht weiß ob EVENTS_N nun ein enum oder ein int const ist und so also eEVENTS_N oder cEVENTS_N heißt. Da sehe ich keinen großen Mehrwert. Ich würde eher sagen nur const benutzen (#define sollte man ja eh nicht benutzen) oä.

du würdest EVENTS_N kennen ohne das prefix zu sehen? naja, aber wie ich schon sagte ist es für die lesbarkeit des codes und dann auch die richtige nutzung davon. es hilft dir natürlich nichts, wenn du etwas suchst. dann mußt du nachsehen ob es ESIGNAL oder EEVENT oder EVENT oder ... gibt.

[unkreativ``]

rapso schrieb:

und mit einer guten styleguid nie vorhanden ist/war.
...
und ebenfals mit einer guten styleguid nie in frage stünde.

Deiner Meinung nach ist also jede weitere Innovation, Weiterentwicklung völlig unnötig, weil Namenskonventionen bereits die perfekte Lösung sind?

Ihr (sämtliche Befürworter von Konventionen mit Präfixen) zählt doch immer nur Argumente auf warum Namenskonventionen besser als gar nichts sind, mich würden aber Vorteile gegenüber heutzutage üblichen IDEs interessieren ..

[rapso]

unkreativ`` schrieb:

rapso schrieb:

und mit einer guten styleguid nie vorhanden ist/war.
...
und ebenfals mit einer guten styleguid nie in frage stünde.

Deiner Meinung nach ist also jede weitere Innovation, Weiterentwicklung völlig unnötig, weil Namenskonventionen bereits die perfekte Lösung sind?

da intepretierst du viel zu viel rein, als ich gesagt habe. natürlich ist eine gute IDE wichtig, ich könnte ohne mein VisualAssist garnicht mehr leben ;).

ich könnte nun aber fragen, glaubst du man sollte gute dinge sein lassen, weil es auf mit ein wenig mehr aufwand auch auf andere weisen ginge?

[THX 1138]

rapso schrieb:

1310-Logik schrieb:

warum nicht gleich so?

//ctor
Foo(unsigned int size_):
size(size_)
{
}

Den Paramter braucht man ja weniger oft als die Membervariable.

weil jemand später mal auf die idee kommen könnte, dass man noch parameter dazubaut

das geht doch dann auch ohne aufwand:

//ctor
Foo(unsigned int size_, unsigned int count_):
size(size_), count(count_)
{
}

oder meinst du grundsätzlich _ als postfix für alle parameter?

Nein nur für Members, denn die Übergabeparameter für Members brauch ich nur in den Konstruktoren und Accessoren, die Membervariable auch in x anderen Methoden der Klasse. Da spar ich mir die Prä/Postfixe dann.

[unkreativ``]

da intepretierst du viel zu viel rein, als ich gesagt habe. natürlich ist eine gute IDE wichtig, ich könnte ohne mein VisualAssist garnicht mehr leben

Ich interpretier da gar nichts hinein und hab auch nichts von IDEs erwähnt in diesem Kontext. Damit wollte ich nur festhalten, dass du andere Ansätze für - ich sag mal - Typbeschreibung mit dem Argument, gibt es bereits "abschmetterst", was auf mich nicht gerade offen gegenüber Innovationen wirkt.

ich könnte nun aber fragen, glaubst du man sollte gute dinge sein lassen, weil es auf mit ein wenig mehr aufwand auch auf andere weisen ginge?

Die Möglichkeiten der IDE zu benutzen ist meiner Ansicht nach ganz klar weniger aufwendig, schon allein deswegen, weil man sich den Kopf freihalten kann, von irgendwelchen Konventionen.

Klarerweise ist das allein kein Argument für IDEs oder nur ein sehr schwaches, andererseits bleibt eben noch die offene Frage im Raum, welchen Vorteil Präfixe im Vergleich zu den Möglichkeiten einer IDE existieren?

[rüdiger]

rapso schrieb:

kingruedi schrieb:

@rapso
Eure Namenskonventionen sehen mir eher danach aus, als wollte man eher die Fehler eines uneinheitlichen Programmierstil reduzieren wollen.

eher als was?
ich denke genau dazu ist unsere styleguide da, sicherlich nicht dazu um programmierer zu unnötigen dingen zu nötigen. deswegen haben wir auch einige dinge rausgenommen gehabt. die styleguide wurde auch gefreezt und auch wenn sie nicht perfekt ist, werden keine ewiglangen diskussionen mehr geführt, sondern man hällt sich daran damit code konstant lesbar bleibt.

Ich meine nur, das eine Namensrichtlinie nicht viel bringt. Natürlich ist es wichtig dass der Code lesbar und weitesgehend einheitlich ist. Aber ich halte nichts davon, dass man Namen mit Typinformationen versieht, die dann auch noch durch 1 buchstabige Abkürzungen ausgedrückt werden.

Ich sehe so ein Vorgehen eher als mangel von Codingrichtlinien. Die müssen ja nicht sehr streng sein und können zum größten Teil aus Effektiv C++ und Exceptional C++ bestehen.

Ich benutze eigentlich sehr wenige POD-structs. Die die ich benutze sind in der Regel ziemlich lokal angesiedelt oder es ist eindeutig zu verstehen das es sich um simple Datensammlungen handelt. Daher würde ich bei einem ImageDescriptor kein zweites mal nachdenken und sofort von einer Klasse ausgehen.

ich nutze structs auch sehr selten, eigentlich fast nur für gemappte resourcen und als initialisierungskonstrukte für factories... aber wie du schon sagst, würdest du darüber nachdenken was ImageDescriptor ist, bei 50leuten die nachdenken, kann es passieren, dass einer was anderes denkt, das ist menschlich.

eigentlich meinte ich, ich würde kein erstes mal nachdenken Aber wie gesagt, es bringt mir keinen Mehrwert zu wissen ob es ein Struct oder eine Klasse ist. (siehe unten)

rapso schrieb:

Aber selbst wenn das alles nicht der Fall ist, so verrät mir ein CImageDescriptor oder ein SImageDescriptor immer noch nicht wie ich die Klasse oder POD-struct benutze.

nein, die benutzung wird dadurch nicht geklärt, da kommt man über gedocte interfaces/header nicht hinweg. aber wenn du einen source liest, weißt du eher was das zu bedeuten hat. aber auf der anderen seite, wenn du im source

apData

siehst, weißt du dass die resource freigegeben wird, bei pData könntest du ein memoryleak oder sogar ne accessviolation bedenken müssen, wenn du das nutzt. einen änlichen unterschied hast du ja bei param-by-reference und param-by-pointer auch. eine funktion die einen pointer annimt MUSS es handlen können dass es ein NullPointer sein kann den sie bekommt. eine die eine reference will, da mußt du dich drum kümmern, dass du sie sauber fütterst. fütterst du eine die einen pointer erwartet, darfst du sie nicht mit "new CFoo" füttern, eine mit nem autopointer/smartpointer/refcountpointer (je nach festlegung) kümmert sich selber um die daten auf die der pointer zeigt.

Hier hilft ein vernünftiger Codingstandard. Die freigabe wird ja nicht dadurch erledigt, in dem man ein p an einen Variablennamen hängt. Hier hilft es zB in dem man Resourcenfreigabe automatisiert. Man sollte also lieber durch die Codelogik Fehler vermeiden und nicht durch Namensgebung.

rapso schrieb:

Oder kannst du mir nun sagen, wie erzeuge ich ein CImageDescriptor oder ein SImageDescriptor? Da ist man eh auf die Dokumentation, ein Blick in den Code oder die IDE angewiesen. Warum benötige ich dann also ein extra C oder S?

ich kann dir sagen, dass du einen SImageDescriptor so erzeugst:
SImageDescriptor Desc;
ich kann dir sagen, dass du ein CImageDescriptor vermutlich über einen konstruktor erzeugst der eventuell parameter braucht (SImageD... hat keine funktionen und ctors)
ich kann dir sagen, dass du ein IImageDescriptor nicht erzeugen könntest, sondern von einer factory erzeugen müßtest, auch deleten könntest du es nicht selbst und müßtest das über die factory machen (oder es gibt ein refcounting, dann würdest du aber einen CAPImadeDescriptor nutzen, der sich um alles kümmert.

das weiß ich alles nur aufgrund des namens ohne dass es die objekt-deklaration überhaupt gibt

Das ist aber ziemlich wenig und ziemlich nutzlos. Gut CImageDescriptor braucht einen Ctor, aber welche Parameter hat er? Welche Daten enthält SImageDescriptor, wie muss ich es also initialisieren? etc. Also muss ich immer noch nachschlagen, wenn ich ImageDescriptor benutzen will. Die gegebenen Informationen bringen mir nichts.

[thinux]

wow, scheint doch ein interessantes thema zu sein? (über 50 comments an einem tag, wenn auch nicht alle so geistreich...)

also, vieleicht ligt es ja daran, dass ich generell beim arbeiten recht ordentlich und struckturiert vorgehe...
ich für meinen teil muss sagen, dass es besonders für eine spätere überarbeitung, fehlersuche oder dokumentation meiner projekte sehr hilfreich ist, wenn man "von weitem" erkennt worum es sich handelt: z.b membervariable(wert) oder membervariable(control), variable die als switch verwndet wird (also bool), welcher typ das Steuerelement hat (txt, lbl, opt, ...) da ich oft meherer Elemente hab die funktionell zusammen gehören und somit den gleichen Namen tragen können zb: m_optConnect, m_cmdConnect, c_optConnect, c_cmdConnect

das würde dann im code so aussehen:

void ... ::OnCmdConnect
 ... blabla.Connect(m_optConnect, blabla);
 m_cmdConnect = "Disconnect";
 c_optConnect.EnableWindow(false);
 ... //oderso...

aber wie gesagt muss jeder selber wissen, ich denke es geht hier weniger um notwendigkeit als und "ordnung und sauberkeit" im code. also klar verstädlich auf den 1. blick...

ein guter stiel beim programmieren ist wie schönschrift bei gedicht und gehört somit einfach dazu

mfg thinux

[Blue-Tiger]

thinux schrieb:

wow, scheint doch ein interessantes thema zu sein? (über 50 comments an einem tag, wenn auch nicht alle so geistreich...)

also, vieleicht ligt es ja daran, dass ich generell beim arbeiten recht ordentlich und struckturiert vorgehe...
ich für meinen teil muss sagen, dass es besonders für eine spätere überarbeitung, fehlersuche oder dokumentation meiner projekte sehr hilfreich ist, wenn man "von weitem" erkennt worum es sich handelt:

Wo wir beim Verarbeiten sind: was machst du wenn erkennst, dass die Ergebnisse deines Programmes nicht genau genug sind, und du deine Variablen alle von float auf double umstellen musst? Durch den ganzen Quelltext gehen und alle "f"-Prefixe durch "d"-Prefixe ersetzen? Oder wenn du statt Comboboxen doch lieber ein List-Element einsetzen willst? alle cmb durch lst ersetzen?

[Jester]

thinux schrieb:

w
ein guter stiel beim programmieren ist wie schönschrift bei gedicht und gehört somit einfach dazu

Du bist offtopic, hier geht's um Stil, nicht um Stiel.

[rapso]

1310-Logik schrieb:

Nein nur für Members, denn die Übergabeparameter für Members brauch ich nur in den Konstruktoren und Accessoren, die Membervariable auch in x anderen Methoden der Klasse. Da spar ich mir die Prä/Postfixe dann.

und wenn du eine neue member einbaust die du nutzen möchtest, prüfst du dann in der implementierungsdatei ob der variablenname schon in funktionen benutzt wurde und änderst den dort oder wie ist der workflow?

[rapso]

unkreativ`` schrieb:

Ich interpretier da gar nichts hinein und hab auch nichts von IDEs erwähnt in diesem Kontext. Damit wollte ich nur festhalten, dass du andere Ansätze für - ich sag mal - Typbeschreibung mit dem Argument, gibt es bereits "abschmetterst", was auf mich nicht gerade offen gegenüber Innovationen wirkt.

nein ich schmetter sie nicht ab, ich verteidige lediglich meine ansicht.

Die Möglichkeiten der IDE zu benutzen ist meiner Ansicht nach ganz klar weniger aufwendig, schon allein deswegen, weil man sich den Kopf freihalten kann, von irgendwelchen Konventionen.

da kann ich dich beruhigen, nach ner zeit hat man es drauf, es ist wie tippen auf der tastatur, darüber muss man nicht mehr nachdenken, man macht es aus gewohntheit dann so.

Klarerweise ist das allein kein Argument für IDEs oder nur ein sehr schwaches, andererseits bleibt eben noch die offene Frage im Raum, welchen Vorteil Präfixe im Vergleich zu den Möglichkeiten einer IDE existieren?

wieso sollten sich IDE und prefixe unbedingt ausschliessen? nur weil man eine IDE hat, muss man doch nicht auf die vorteile einer styleguide verzichten. ich kann jetzt natürlich das argument bringen, dass nicht jede IDE gleich arbeitet und gerade diff-tools oft auf das highlighting von unterschieden spezialisiert sind, nicht auf syntax;) und sourcebrowsen in sourcedatenbanken ganz andere highlights setzt.