Multiplikation *

Der Multiplikations-Operator führt eine Multiplikation zweier Elemente aus. Für arithmetische Typen entspricht dies der mathematischen Multiplikation zweier Zahlen.

64
6
10
15.000000

#include <stdio.h>

int main(){
  int a = 2;
  int b = 3;
  float c = 7.5f;
  printf("%d\n",  8 * 8);
  printf("%d\n",  a * b);
  printf("%d\n",  a * 5);
  printf("%f\n",  a * c);
  return 0;
}

Siehe auch Divisions-Operator /

Details

Der Multiplikations-Operator erwartet zwei Operanden als rvalues und wird von links nach rechts abgearbeitet. Der Rückgabewert ist ein rvalue, dessen Typ grundsätzlich durch die arithmetische Umwandlung der beiden Operanden festgelegt ist.

Der Operator ist zulässig für arithmetische (Integer- und Fliesskomma-) Typen sowie den bool-Typ. Boolsche Werte werden als Integer-Werte aufgefasst. Die Operanden werden gegebenfalls entsprechend den Regeln der arithmetischen Umwandlung gecastet.

Der Multiplikations-Operator entspricht bei arithmetischen Typen grundsätzlich der mathematischen Multiplikation, wobei man die beiden Operanden auch Faktoren nennt. Aufgrund der Rangordnung der Operatoren ist es möglich, einen Positiv- oder Negativ-Operator bei den beiden Faktoren direkt hinzuschreiben.

-50
15
25

  int a = 5;
  printf("%d\n",  10 * -a);
  printf("%d\n",  a  * +3);
  printf("%d\n",  -a * -a);

Der Multiplikations-Operator entspricht der direkten Umsetzung des entsprechenden Multiplikations-Befehls in Assembler und kann somit für arithmetische Typen einen Over- oder Underflow ergeben, was bei Integer-Typen zu einem Wrap-Around führt. Bei Fliesskomma-Typen kann dies zum Wert Unendlich führen.

1705032704

1.000000e+20
inf

  unsigned int a = 3000000000;
  printf("%u\n",  a * 2);
  float b = 1e20;
  printf("%le\n",  b);
  printf("%le\n",  b * b);

Überladen des Operators

Der Multiplikations-Operator hat grundsätzlich die semantische Bedeutung einer Multiplikation im mathematischem Sinne. Allerdings gibt es Klassen, die eine andere Semantik definieren, beispielsweise die Multiplikation zweier Mengen, was in einem sogenannten Power-Set resultiert. Auch weitere, ähnliche Anwendungen des Multiplikations-Operators wären denkbar.

Die Prototypen für das Überladen des Multiplikations-Operators sind die folgenden (Einschränkungen und Erläuterungen siehe Überladen von Operatoren):

inside class


outside class

Type operator *(Type);
Type operator *(Type) const;

Type operator *(Type, Type);

Vorsicht ist geboten bei dem nicht-const Prototypen innerhalb der Klasse: Wenn er ausserhalb der Klasse steht, wird er von den Compilern nicht als Fehler erkannt, da er einem Prototypen des Dereferenz-Operators entspricht.

Im folgenden Beispiel wird eine Klasse präsentiert für eine 2x2 Matrix. Der überladene Multiplikations-Operator definiert hier die Multiplikation zweier Matrizen.

2.000000, 4.000000
6.000000, 8.000000

#include <cstdio>

class Matrix22{
  float a[4];
public:
  Matrix22(float d1, float d2, float d3, float d4){
    a[0]=d1; a[1]=d2; a[2]=d3; a[3]=d4;
  }
  void print(){printf("%f, %f\n%f, %f\n",
                      a[0], a[1], a[2], a[3]);}
  
  Matrix22 operator *(Matrix22& m2) const {
    return Matrix22(a[0]*m2.a[0] + a[1]*m2.a[2],
                    a[0]*m2.a[1] + a[1]*m2.a[3],
                    a[2]*m2.a[0] + a[3]*m2.a[2],
                    a[2]*m2.a[1] + a[3]*m2.a[3]);
  }
};

int main(){
  Matrix22 m1(1, 2, 3, 4);
  Matrix22 m2(2, 0, 0, 2);
  (m1 * m2).print();
  return 0;
}