D Programming Language 2.0 -> const oder in?

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • D Programming Language 2.0 -> const oder in?

    Mit D2.0 wurde ja die Bedeutung von "in" als Storage Class als alias für const geändert. Was würdet ihr eher verwenden, wenn ihr sicherstellen wollt, dass ein Paraeter nicht mehr geändert wird im Funktionskopf?
    "in "

    Quellcode

    1. int calculate(in ushort x, in ushort y) {


    oder "const "

    Quellcode

    1. int calculate(const ushort x, const ushort y) {


    oder gar nichts

    Quellcode

    1. int calculate(ushort x, ushort y) {

    ?

    Einfach mal so Interessen halber.
    "in" ist kürzer (und als Programmierer ist man ja eher faul), allerdings ist "const" Aussagekräftiger.
    Deswegen wollt ich mal rumfragen (evtl. macht ja Thorben 'ne Umfrage draus).

    Gruß

  • Also ich habe noch keinen wirklichen Unterschied feststellen können, denn auch wenn ich mittels typeid die Parameter mir ausgeben lasse, sehe ich bei beiden const(PARAM). Auch bei diesem Test (wir brauchen hier mal einen D Syntax):

    Quellcode

    1. import std.stdio;
    3. struct Node {
    4. void print(in byte nr) const {
    5. writefln("Node print [%d]", nr);
    6. }
    7. }
    9. class Parent {
    10. this(in Node n) {
    11. n.print(0);
    12. writeln(typeid(n));
    13. }
    15. this(const Node n) {
    16. n.print(1);
    17. writeln(typeid(n));
    18. }
    20. void init(in int[] array) {
    21. writeln("in");
    22. writeln(typeid(array));
    23. //array[0] = array[0] + 42;
    24. foreach (ref int e; array) {
    25. writeln(e);
    26. //e++;
    27. }
    28. }
    30. void init_(const int[] array) {
    31. writeln("const");
    32. writeln(typeid(array));
    33. //array[0] = array[0] + 42;
    34. foreach (ref int e; array) {
    35. writeln(e);
    36. //e++;
    37. }
    38. }
    39. }
    42. void main() {
    43. Node n = Node();
    44. auto p = new Parent(n);
    45. p.init([1, 2, 3, 4, 5, 6, 7, 8, 9,]);
    46. p.init_([1, 2, 3, 4, 5, 6, 7, 8, 9,]);
    47. }
    Alles anzeigen

    (die auskommentierten Zeilen wurden mir angekriedet, gerade wegen der const Beziehung)

    bekam ich zu aller erst dies hier:

    C:\Users\White\Desktop\d zauberei>dmd const_ref.d
    const_ref.d(42): Error: constructor const_ref.Parent.this called with argument t
    ypes:
    ((Node))
    matches both:
    const_ref.Parent.this(in const(Node) n)
    and:
    const_ref.Parent.this(const const(Node) n)


    Und nachdem ich den Konsturktor mit dem const Parameter auskommentiert hatte, dies:
    Node print [0]
    const(const_ref.Node)
    in
    const(const(int)[])
    1
    2
    3
    4
    5
    6
    7
    8
    9
    const
    const(const(int)[])
    1
    2
    3
    4
    5
    6
    7
    8
    9

    Also scheint intern beides gleich behandelt zu werden.
    Du würdest also const verwenden? Und wenn, weswegen? Aussagekräftiger, Gewohnheit?

  • Wenn man in der doc zu den functions ein bisschen rumwühlt, gibt es dazu keine eindeutigen Erkenntnisse :wacko:

    Wenn ich das richtig verstanden habe, dann sollen die hauptsächlich noch unterstützten storage classes in, out, ref, lazy und none sein.

    Inkonsequent ist, dass die "alten" (immutable, scope, const, final) Bezeichner noch alle unterstützt, in der 2.0er Version übernommen und nirgends aus deprecated gekennzeichnet wurden.



    Zumindestens macht dann die Einführung und Bezeichnung von in einen Sinn und wäre für mich dann dem const vorzuziehen.


    Quellcode

    1. void abc(out int x) {
    2. x = 2;
    3. }
    4. int y = 3;
    5. abc(y); // y=2
    7. ////////////
    9. void abc(in int x) {
    10. x = 2;
    11. }
    12. int y = 3;
    13. abc(y); // y=3
    15. ////////////
    17. void abc(ref int x) {
    18. x += 1;
    19. }
    20. int z = 3;
    21. abc(z); // z=4
    Alles anzeigen

  • hi,

    ich meinte das in Bezug auf die Parameter storage classes.


    Für eine normale Konstante macht const, anstatt in, auch mehr Sinn.

    Ja, hast du Recht, immutable kam neu dazu ... ich bin bei D auch schon länger "raus" ^^


    rswhite schrieb:


    Soweit ich weiß wird final für Klassen und const weiterhin für Methode, welche als Unveränderlich gekennzeichnet werden sollen, gebraucht.

    Das wäre ja fast die Antwort auf deine anfängliche Frage ;)

    Offizielle Konventionen von D hab ich nicht gefunden, aber wenn man sich an die inout storage classes hält, dann brauch man bei den Parametern kein const, immutable etc. mehr.