Ik denk dat een objectgeorienteerde oplossing hier een betere aanpak is (al kent deze standaard geen voorgangregels en zal je dat zelf moeten afhandelen als dat nodig is). Ik zou er zelf voor kiezen om een klasse operator te maken die voor alle operaties gebruikt kan worden en de daadwerlijke functionaliteit van de operator onder te brengen in een aparte klasse waardoor alle functionaliteit die bij een bepaald onderdeel horen ook bij dat onderdeel verzameld staat en je geen god klasse hoeft te maken door de functionaliteit van de verschillende onderdelen in één klasse onder te brengen.
De implementatie zou er bijvoorbeeld als volgt uit kunnen zien:
[cpp]
public enum OperatorType {
MIN, PLUS, DELEN, VERMENIGVULDIGEN;
}
public abstract class AbstractOperatorType {
private OperatorType type;
private String teken;
public AbstractOperatorType(OperatorType type, String teken) {
this.type = type;
this.teken = teken
}
public OperatorType getType() {
return type;
}
public String getTeken() {
return teken;
}
public abstract int bereken(int left, int right);
}
public class Operator {
private AbstractOperatorType type;
public Operator(AbstractOperatorType type) {
this.type = type;
}
public OperatorType getType() {
return type.getType();
}
public String getTeken() {
return type.getTeken();
}
public int bereken(int left, int right) {
return type.bereken(left, right);
}
}
// voor iedere operator implementeer je nu de bijbehorende bereken methode
public class MinOperatorType : AbstractOperatorType {
public MinOperatorType() : base(OperatorType.MIN, "-") {
}
public override int bereken(int left, int right) {
return left - right;
}
}
public class PlusOperatorType : AbstractOperatorType {
public PlusOperatorType() : base(OperatorType.PLUS, "+") {
}
public override int bereken(int left, int right) {
return left + right;
}
}
public class DelenOperatorType : AbstractOperatorType {
public DelenOperatorType() : base(OperatorType.DELEN, "/") {
}
public override int bereken(int left, int right) {
return left / right;
}
}
public class VermenigvuldigOperatorType : AbstractOperatorType {
public VermenigvuldigOperatorType() : base(OperatorType.VERMENIGVULDIGEN, "*") {
}
public override int bereken(int left, int right) {
return left * right;
}
}
[/cpp]
Voor het genereren van random operators zou je dan bijvoorbeeld iets als dit kunnen doen:
[cpp]
private const int aantalTypes = 4;
private Random random = new Random();
public Operator generateRandomOperator() {
int r = random.nextInt() % aantalTypes;
if (r == 0) return new Operator(new MinOperatorType());
if (r == 1) return new Operator(new PlusOperatorType());
if (r == 2) return new Operator(new DelenOperatorType());
if (r == 3) return new Operator(new VermenigvuldigOperatorType());
}
[/cpp]
Ik heb de code niet getest en werk tegenwoordig nog maar zelden in .NET, dus wellicht is het noodzakelijk om een paar kleine dingen te wijzigen. Maar daar kom je zelf wel uit neem ik aan. Verder heb ik het simpel gehouden en voor iedere berekening uitgegaan van een int en moet je dit ook zelf even aanpassen mocht je het anders willen.
edit: stukje code vergeten te posten:
[cpp]
// voor iedere operator implementeer je nu de bijbehorende bereken methode
public class MinOperatorType : AbstractOperatorType {
public MinOperatorType() : base(OperatorType.MIN, "-") {
}
public override int bereken(int left, int right) {
return left - right;
}
}
public class PlusOperatorType : AbstractOperatorType {
public PlusOperatorType() : base(OperatorType.PLUS, "+") {
}
public override int bereken(int left, int right) {
return left + right;
}
}
public class DelenOperatorType : AbstractOperatorType {
public DelenOperatorType() : base(OperatorType.DELEN, "/") {
}
public override int bereken(int left, int right) {
return left / right;
}
}
public class VermenigvuldigOperatorType : AbstractOperatorType {
public VermenigvuldigOperatorType() : base(OperatorType.VERMENIGVULDIGEN, "*") {
}
public override int bereken(int left, int right) {
return left * right;
}
}
[/cpp]
