# Prüfen ob A und B größer als C



## GR-Thunderstorm (7. September 2010)

*Prüfen ob A und B größer als C*

Ich schreibe gerade an einem Code und will folgendes machen:

Ich habe ein Array mit 3 Elementen, welches als Vektor zu verstehen ist.
Nun möchte ich auf Knopfdruck die beiden größten Werte mit -1 multiplizieren.


```
if ((Angle[1] & Angle[2]) > Angle[3])
{
Angle[1] *=-1;
Angle[2] *=-1;
}
else if ((Angle[2] & Angle[3]) > Angle[1])
{
Angle[2] *=-1;
Angle[3] *=-1;
}
else
{
Angle[1] *=-1;
Angle[3] *=-1;
}
```
1. Frage: Er meckert zwar nicht beim Compilieren, aber macht "_if ((Angle[1] & Angle[2]) > Angle[3])_" tatsächlich das, was ich mir darunter vorstelle, oder kommt dabei Murks raus? ^^ Ich kann es leider noch nicht testen, da mein Programm noch weit von der Fertigstellung entfernt ist.

2. Frage: Gäbe es noch einen performanteren Weg, die beiden größten Elemente meines Arrays zu negieren?


----------



## Mastermaisi777 (7. September 2010)

*AW: Prüfen ob A und B größer als C*



GR-Thunderstorm schrieb:


> 2. Frage: Gäbe es noch einen performanteren Weg, die beiden größten Elemente meines Arrays zu negieren?


Wird das Array noch größer ? Wenn ja solltest du mal mit Quicksort beschäftigen. Bei 3 Elementen erscheint mir das aber sinnlos.

1. Sollte schon klappen .


----------



## GR-Thunderstorm (7. September 2010)

*AW: Prüfen ob A und B größer als C*

Nein, das Array bleibt so groß.

Danke für die schnelle Antwort.


----------



## Mastermaisi777 (7. September 2010)

*AW: Prüfen ob A und B größer als C*

Was mir grad noch eingefallen ist , was machst du wenn die Elemente gleich groß sind ?


----------



## boerigard (7. September 2010)

*AW: Prüfen ob A und B größer als C*

Um welche Programmiersprache geht es denn hier?

Ich gehe mal von C oder C++ aus (falls es hier um eine .net Sprache geht, brauchst du nicht weiterlesen). Also erstmal, bei Arrays (Vectoren) fängt die Indices-Zählung bei 0 an, dh. in deinem Falle sind 0,1 und 2 gültige Indices. Angle[3] gibt es also nicht.
Dann ist der &-Operator eine bitweise Und-Verknüpfung. Du willst aber ein logisches Und, das wäre dann &&.
Dein Vergleich muss dann aber trotzdem noch umgeschrieben werden:

```
if((Angle[0] > Angle[2]) && (Angle[1] > Angle[2]))
```

Btw. testen kannst du doch deinen Code auch schon vorher. Einfach ein kleines Consolenprogramm erstellen und schon kannst du deinen Code testen.


----------



## Mastermaisi777 (7. September 2010)

*AW: Prüfen ob A und B größer als C*



boerigard schrieb:


> Btw. testen kannst du doch deinen Code auch schon vorher. Einfach ein kleines Consolenprogramm erstellen und schon kannst du deinen Code testen.



Also unter C funktioniert sein Code , gerade eben getestet.

Auch Array[3] funktioniert solange das [4] groß ist  Ist zwar Speicherplatzverschwendung ,geht aber .


----------



## GR-Thunderstorm (7. September 2010)

*AW: Prüfen ob A und B größer als C*



boerigard schrieb:


> dh. in deinem Falle sind 0,1 und 2 gültige Indices. Angle[3] gibt es also nicht.



Args.. Daran hab ich gar nicht mehr gedacht... 



> Was mir grad noch eingefallen ist , was machst du wenn die Elemente gleich groß sind ?


Dann tritt der letzte Punkt in Kraft. ^^ Ja, es muss und soll nicht logisch sein. ^^

Und danke, dass du es für mich getestet hast.  Dann sollte es wohl auch unter C++ gehen, oder?


Ich habe da noch eine kleine Ergänzungsfrage:
Wie funktioniert das mit Try und Catch unter C++?

Ich möchte quasi testen, ob auf Angle[3] zugegriffen wird, was ja nicht existiert. Fall dies geschieht, soll automatisch ein bestimmter Code ausgeführt werden.

Pseudocode, um mein Aliegen zu verdeutlichen:

```
int a = 0;
int b = 0;
int Angle[3]=0;
do
{
try (Angle[a]=1); /*Bei Angle[3]=1 würde das Programm einen Fehler verursachen, was durch "try" durch einen Vortest verhindert werden soll*/
catch /*Falls der Vortest einen Fehler ergab, soll dieser Code ausgeführt werden*/
{
a=0;
b=1;
}
a++

}
while (b == 0);
```
Gibt es diese Funktion unter C++ überhaupt? Ich kenne das sonst nur aus Delphi.


----------



## Bauer87 (7. September 2010)

*AW: Prüfen ob A und B größer als C*

Der Code funktioniert, aber macht wohl nicht das, was er soll. Das Problem mit der bitweisen Und-Verknüpfung hat ja boerigard schon erklärt. Selbst mit richtigem „und“ (also „and“ oder c-Style „&&“ im Code) würde der Code wie du ihn geschrieben hast etwas machen:

```
(Angle[1] && Angle[2]) > Angle[3]
```
Prüft, ob Angle[1] und Angle[2] beide wahr sind. Dabei kommt dann „true“ oder „false“ raus. Im zweiten Schritt wird dann geprüft, ob Angle[3] kleiner als der bool-Wert ist. (Ich hoffe, dass ich das so richtig verstanden habe, im Zweifelsfall laut schreien.)

Was du willst, ist folgendes:

```
if((Angle[0] > Angle[2]) && (Angle[1] > Angle[2]))
```

Warum die Zuweisung „Angle[a]=1“ eine Exception werfen sollte, ist mir nicht klar.


----------



## GR-Thunderstorm (7. September 2010)

*AW: Prüfen ob A und B größer als C*



Bauer87 schrieb:


> Der Code funktioniert, aber macht wohl nicht das, was er soll. Das Problem mit der bitweisen Und-Verknüpfung hat ja boerigard schon erklärt. Selbst mit richtigem „und“ (also „and“ oder c-Style „&&“ im Code) würde der Code wie du ihn geschrieben hast etwas machen:
> 
> ```
> (Angle[1] && Angle[2]) > Angle[3]
> ...



Ok, dann muss ich es wohl tatsächlich so schreiben... Ich hatte gehofft,  dass ich zu gunsten der Ausführungsgeschwindigkeit die beiden  Vergleiche quasi zu einem zusammenfassen kann.



Bauer87 schrieb:


> Warum die Zuweisung „Angle[a]=1“ eine Exception werfen sollte, ist mir nicht klar.



Weil a in der Schleife immer größer wird.

Das Beispiel sollte ja nur dazu dienen zu zeigen, auf was ich hinaus möchte. 
Ich will es einsetzen, um dem PC im fertigen Programm einen nicht unerheblichen Zeitaufwand zu ersparen, da damit sehr viele nachfolgende Vergleiche vermieden werden können, falls im Vorraus feststeht, dass diese nicht notwendig sind.


----------



## Bauer87 (8. September 2010)

*AW: Prüfen ob A und B größer als C*

Warum du willst, dass es das (im Fehlerfall) macht, ist recht egal. Es ist aber eine einfache Zuweisung und wird von allein keine werfen.

Wenn du Exceptions haben willst, musst du sie schon selber werfen (oder Klassen benutzen, die das tun).

```
class Angle{
private:
    std::vector<int> value;
public:
    setValue(unsigned short, int);
    getValue(unsigned short);
};

Angle::setValue(unsigned short v, int a){
    if (v > value.size()){
        throw MyException("Generic error.");
    } else {
        value[v] = a;
    }
}

int main(){
    …
    try{
        angle.setValue(v,a);
    } catch (MyException& e){
        std::cerr << e.what();
        v = 0;
    }
    …
}
```


----------



## bingo88 (8. September 2010)

*AW: Prüfen ob A und B größer als C*

C/C++ tut dir leider nicht den Gefallen bei normalen Arrays mal ne Exception zu werfen. Da wird dann so getan, als gehört dir dieser Speicher und du pinselst fröhlich rein. In der Regel haut dir dann aber das Betriebssystem auf die Finger. Wenn du richtig Pech hast, kann man dadurch sogar Schadcode einschleusen und ausführen. Ist also besser, solche Szenarien ganz zu vermeiden indem man dafür sorgt, dass die Arraygrenzen nicht über (oder unterschritten) werden


----------

