Reihenfolge Funktionsparameter

[Walter T. (nicolas)]

Guten Morgen,

wenn ihr eine Funktion programmiert - welche Reihenfolge der 
Funktionsparameter wäre für euch am logischsten?

uint_fast8_t ee24Cx_update_block(uint8_t *buffer, uint16_t addr, size_t size);
uint_fast8_t ee24Cx_update_block(uint16_t addr, uint8_t *buffer, size_t size);
uint_fast8_t ee24Cx_update_block(size_t size, uint8_t *buffer, uint16_t addr);
uint_fast8_t ee24Cx_update_block(uint16_t addr, size_t size, uint8_t *buffer);

oder gar eine der beiden nicht aufgeführten Varianten?

Wie sieht es bei Funktionen aus, die nur Eingänge haben?

update_display(const FixedData_t *const FixedData, VariableData_t *const VariableData, bool flag);
update_display(VariableData_t *const VariableData, const FixedData_t *const FixedData, bool flag);

oder noch eine andere Variante?

[Oliver S. (oliverso)]

Den System der C-Library-Funktionen folgen, in dem Fall z.B

void * memset ( void * ptr, int value, size_t num );

Oliver

[Peter D. (peda)]

Gerne genommen wird: Ziel, Quelle, Attribut

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Bei der memset() Funktion ist der Pointer auf den Speicher ja das 
Wichtigste. So ein schnöder "Buffer" ist aber ggfs völlig uninteressant 
und wird von allen möglichen Funktionen verwendet.

Ich schreibe nach links das, was die Funktion eigentlich "interessant" 
macht und sich laufend ändert. Und dann in Richtung rechts als nächstes 
das, was konstant ist und dann das, was man "halt zum Funktionieren 
braucht". So wie die memset() das auch macht: woihn? was? wieviel?

Und bezogen auf die ursprüngliche Frage lautet deshalb die Antwort 
"alles möglich, kommt drauf an".

[Marten Morten (Gast)]

Was zusammen gehört wird direkt hintereinander übergeben:

Eigentliche Daten vor Metadaten, vor Steuerdaten. D.h. zum Beispiel 
Pointer vor der Speichergrösse auf die der Pointer zeigt. Metadaten in 
der Reihenfolge ihrer gefühlten Wichtigkeit. Steuerdaten, Flags, die das 
Verhalten der Funktion steuern zuletzt.

Bei C++ müssen die Parameter mit Default-Werten sowieso ans Ende, da 
kann man nicht immer die typische Reihenfolge einhalten.

Unterschiedliche Meinungen gibt es über die Reihenfolge von übergebenen 
Daten und zurückgegebenen Daten.

Entweder:

Zurück vor übergeben: f(int *out1, double *out2, int in1, bool in2); 
weil das der Reihenfolge bei einem Funktionsaufruf ähnelt out = f(in); 
und weil es besser zu C++ Default-Argumenten passt.

Oder:

Übergeben vor zurück f(int in1, bool in2, int *out1, double *out2); weil 
es angeblich flüssiger zu lesen ist.

[DPA (Gast)]

Ich schreibe gerne das Ziel vor der Quelle.
Buffergrössen schreibe ich gerne vor den Buffer, so:

int do_something(
  size_t dst_size, char dst[dst_size],
  size_t src_size, char src[src_size]
);

Obwohl, ich halte mich auch nicht immer daran, und es ist eher weil 
"char a[b], size_t b" halt nicht funktioniert, und mir die T x[N] 
schreibweise besser gefällt als die T* x schreibweise.