Surcharge de l'opérateur C++ pour les opérations de nombres complexes

Question

J'ai une affectation en C++ et j'ai du mal à démarrer. Le but est de "concevoir une classe qui utilise les opérateurs surchargés suivants pour les nombres complexes: >> < < + - * /"

Ma question n'est pas sur la syntaxe de ceci, mais plus sur la logique. Je pourrais utiliser un peu d'aide au brain storming.

entrée échantillon:
2,5 -2,2
1,0 1,0

exemple de sortie:
A = (2,5) + (-2,2) i
B = (1,0) + (1,0) i

A + B = (3,5) + (-1,2) i
A - B = ..............
A * B = ........ ......
A/B = ..............

Alors, comment puis-je commencer? La classe "Complex" surcharge ces opérateurs, cela signifie-t-il que je ne peux utiliser ces opérateurs que dans la classe (c'est-à-dire dans des fonctions publiques)? Si oui, est-ce que je voudrais le faire de cette façon? Ou est-ce que je voudrais le faire dans mon code client/pilote? Deuxièmement, s'agit-il simplement d'ajouter i à la deuxième valeur de chaque ligne? Cela semble trop facile. Toute direction serait très appréciée. (Juste pour le compte rendu, je ne cherche personne pour faire mes devoirs pour moi ... pourrait juste utiliser une entrée)

Answer 1

Il me semble que le but est de démontrer une surcharge de fonctionnement de classe, donc je pense que le idée est pour vous de faire un complexe de classe qui contient des informations sur le nombre réel et le nombre imaginaire (le i signifie que c'est imaginaire). Gérer diverses opérations entre des nombres complexes dans les remplacements d'opérateur que vous faites vous-même.

Une fois que vous avez cela et que vous voyez que cela fonctionne (faites une méthode de test statique qui effectue diverses opérations et imprime les résultats à l'écran), alors utilisez cette entrée pour travailler avec l'entrée en soi. Parfois, il est plus simple de diviser les problèmes en problèmes plus petits que d'essayer de faire les deux en même temps.

Espérons que ça aide. Bonne chance!

Answer 2

Ils aiment paires de valeurs:

A = N1 + I1i 
B = N2 + I2i 


A + B = (N1 + I1i) + (N2 + I2i) 
     = N1 + I1i + N2 + I2i 
     = (N1 + N2) + (I1i + I2i) 
     = (N1 + N2) + (I1 + I2)i 
A - B = (N1 + I1i) - (N2 + I2i) 
     = N1 + I1i - N2 - I2i 
     = (N1 - N2) + (I1i - I2i) 
     = (N1 - N2) + (I1 - I2)i 

// N1, N2, I1, I2 are all just normal numbers. 
// You can multiply them like normal. You just have to keep track of the `i` 
// Also not that i = sqrt(-1) 
// Therefore i * i = sqrt(-1) * sqrt(-1) 
//     = sqrt(-1)^2 
//     = -1 
A * B = (N1 + I1i) * (N2 + I2i) 
     = (N1 * N2) + (N1 * I2i) + (I1i * N2) + (I1i * I2i) 
     = (N1 * N2) + (N1 * I2)i + (N2 * I1)i + (i * i * I1 * I2) 
     = (N1 * N2) + i((N1 * I2) + (N2 * I1)) + (-1 * I1 * I2) 

     // Simplest form 
     = ((N1 * N2) - (I1 * I2)) + ((N1 * I2) + (N2 * I1))i 


A/B = Repeat as above. 

Answer 3

Vous avez besoin de concevoir une classe appelée complexe qui comprend au moins:

• un constructeur qui vous permet de construire un objet complexe de réel et imaginaire valeurs des composants Complexe (1, 5)

• remplace l'opérateur + afin que vous puissiez ajouter deux objets complexes, en retournant un nouvel objet complexe, par exemple.Complexe (1, 5) + complexe (3, 7) est complexe (4, 12)

• de même pour d'autres opérateurs

Mais d'abord, vous devez comprendre les mathématiques de base derrière les nombres complexes de sorte que vous pouvez écrire les méthodes de surcharge de l'opérateur.

Answer 4

Il y a quelques choses que vous devez faire pour accomplir cette tâche:

définit une classe (par exemple complexe) qui peut contenir les données pour la partie réelle et imaginaire d'un nombre complexe.

surcharge les opérateurs respectifs (par exemple):

class Complex 
{ 
public: 
    // other declarations here 
    Complex operator+ (const Complex& rhs) const; 
    // other stuff here 
}; 

Mettre en œuvre les opérateurs respectifs pour effectuer réellement l'opération mathématique (par exemple):

Complex Complex::operator+ (const Complex& rhs) const 
{ 
    Complex result = *this; 
    result.Real += rhs.Real; 
    result.Imaginary += rhs.Imaginary; 
    return result; 
}