Moin. Im D Forum geht gerade ein Vergleich zwischen D und C++ um, und da wollte ich doch glatt mal um Rat fragen. Die C++ Gurus unter euch können mir sicher sagen, ob es einen Weg gibt,
const als Modifier zu ermitteln. Zum besseren Verständnis mal der D Code:
|
Quellcode
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
import std.stdio : writeln;
class Visitor {
public:
void visit(inout A a) {
writeln("visit A");
}
void visit(inout B b) {
writeln("visit B");
}
}
class A {
public:
void accept(Visitor v) inout {
v.visit(this);
}
}
class B : A {
public:
override void accept(Visitor v) inout {
v.visit(this);
}
}
void main() {
Visitor v = new Visitor();
const A a = new A();
A b = new B();
a.accept(v);
b.accept(v);
}
|
inout ist ein "wildcard", dass automatisch
const deduziert, sofern der Typ
const ist. Andernfalls bleibt der Typ, wie beschrieben.
Das gleiche in C++ zu erreichen, ist etwas umständlicher. Jedenfalls das Konstrukt, was mir als Lösung einfiel:
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
|
#include <iostream>
#include <type_traits>
#include <memory>
class A;
class B;
enum class State {
Mutable,
Immutable
};
template <State S>
class Visitor {
public:
using A_T = typename std::conditional<S == State::Immutable, const A, A>::type;
using B_T = typename std::conditional<S == State::Immutable, const B, B>::type;
void visit(A_T* a) {
std::cout << "visit A" << std::endl;
}
void visit(B_T* b) {
std::cout << "visit B" << std::endl;
}
};
class A {
public:
virtual void accept(Visitor<State::Mutable>& mv) {
mv.visit(this);
}
virtual void accept(Visitor<State::Immutable>& iv) const {
iv.visit(this);
}
};
class B : public A {
public:
virtual void accept(Visitor<State::Mutable>& mv) {
mv.visit(this);
}
virtual void accept(Visitor<State::Immutable>& iv) const {
iv.visit(this);
}
};
int main() {
std::unique_ptr<const A> a(new A());
std::unique_ptr<A> b(new B());
Visitor<State::Mutable> mv;
Visitor<State::Immutable> iv;
a->accept(iv);
b->accept(mv);
}
|
Nun meine Frage: Geht das schöner/besser/eleganter/kürzer?