- = 연산자가 올바르게 작동하지 않고 숫자가 증가 할 때

Question

이 프로그램은 영웅을 서로 싸우게하고 상대방과 맞서 싸우는 승자와 라운드 수를 표시합니다. 이 형식과 비슷합니다. 내가 추측하고

Ancient Battle! Achilles vs Hector : Winner is Hector in 4 rounds. 

The thing is, the program would print out like this : 

Greek Heroes 
Quarter Finals 
Ancient Battle! vs Hector : Winner is in 7 rounds.        
Ancient Battle! Achilles vs Hector : Winner is Hector in 4 rounds. 
Ancient Battle! Hercules vs Theseus : Winner is Hercules in 3 rounds. 
Ancient Battle! Odysseus vs Ajax : Winner is Ajax in 3 rounds. 
Ancient Battle! Atalanta vs Hippolyta : Winner is Atalanta in 3 rounds. 

Semi Finals 
Ancient Battle! Hector vs Hercules : Winner is Hector in 6 rounds. 
Ancient Battle! Ajax vs Atalanta : Winner is Ajax in 2 rounds. 

Finals 
Ancient Battle! Hector vs Ajax : Winner is Hector in 3 rounds. 



However, what it should logically print out is : 

Greek Heroes 
Quarter Finals 
Ancient Battle! vs Hector : Winner is in 7 rounds. 
Ancient Battle! Achilles vs Hector : Winner is Hector in 4 rounds. 
Ancient Battle! Hercules vs Theseus : Winner is Hercules in 4 rounds. 
Ancient Battle! Odysseus vs Ajax : Winner is Ajax in 3 rounds. 
Ancient Battle! Atalanta vs Hippolyta : Winner is Atalanta in 4 rounds. 

Semi Finals 
Ancient Battle! Hector vs Hercules : Winner is Hector in 7 rounds. 

Ancient Battle! Ajax vs Atalanta : Winner is Ajax in 2 rounds. 

Finals 
Ancient Battle! Hector vs Ajax : Winner is Hector in 4 rounds. 

이 함께 할 수있는 뭔가가 - = 연산자 논리를 그리고 난 그것을 알아낼 수 없습니다. 어떤 도움이 필요합니까?

Hero.cpp

#include "Hero.h" 
#include <iostream> 
#include <cstring> 
using namespace std; 
namespace sict { 

    Hero::Hero() 
    { 
     m_name[0] = '\0'; 
     m_health = 0; 
     m_attack = 0; 

    } 



    Hero::Hero(char name[], int health, int attack) 
    { 

     if (m_name != nullptr || m_name != "") { 
      strcpy(m_name, name); 

     } 
     else { 
      m_name[0] = '\0'; 
     } 

     m_attack = attack; 
     m_health = health; 


    } 

    void Hero::operator-=(int attack) { 
     if (attack > 0) { 
      m_health -= attack; 
     } 
     if (attack > m_health) { 
      m_health = 0; 
     } 
    } 
    bool Hero::isAlive() const { 
     if (m_health > 0) { 
      return true; 
     } 
     else { 
      return false; 
     } 
    } 
    int Hero::attackStrength() const { 
     if (m_attack == 0) { 
      return 0; 
     } 
     else { 
      return m_attack; 
     } 
    } 
    ostream& operator<<(ostream& os, const Hero& hero) { 
     if (hero.m_name == '\0') { 
      os << "No Hero"; 
     } 
     else { 
      os << hero.m_name; 
     } 
     return os; 
    } 
    const Hero& operator*(const Hero& first, const Hero& second) { 
     cout << "Ancient Battle! "; 
     cout << first; 
     cout << " vs "; 
     cout << second; 
     cout << " : "; 
     Hero A = first; 
     Hero B = second; 
     const Hero *winner = nullptr; 
     int max_rounds = 0; 
     while (A.isAlive() && B.isAlive() && max_rounds < 200) { 
      max_rounds++; 
      A -= B.attackStrength(); 
      B -= A.attackStrength(); 

     } 

     bool draw; 

     if (A.isAlive() && B.isAlive()) { draw = true; } 
     else { draw = false; } 

     if (draw) { 
      winner = &first; 
     } 
     else if (A.isAlive()) 
     { 
      winner = &first; 
     } 
     else { 
      winner = &second; 
     } 
     cout << "Winner is "; 
     cout << *winner; 
     cout << " in " << max_rounds << " rounds. " << endl; 
     return *winner; 

    } 
} 

Hero.h

#ifndef SICT_HERO_H_ 
#define SICT_HERO_H_ 
#include <iostream> 
namespace sict { 
    class Hero { 
     char m_name[41]; 
     int m_health; 
     int m_attack; 
    public: 
     Hero(); 
     Hero(char name[], int health, int attack); 
     void operator-=(int attack); 
     bool isAlive() const; 
     int attackStrength() const; 
     friend std::ostream& operator<<(std::ostream& os, const Hero& hero); 
    }; 
    const Hero& operator*(const Hero& first, const Hero& second); 
} 
#endif 

하여 Main.cpp는

#include <iostream> 
#include "Hero.h" 

using namespace std; 
using namespace sict; 

int main() { 

    cout << "Greek Heroes"; 
    Hero moneyhunger("", 40, 4); 
    Hero hercules("Hercules", 32, 4); 
    Hero theseus("Theseus", 14, 5); 
    Hero oddyseus("Odysseus", 15, 3); 
    Hero ajax("Ajax", 17, 5); 
    Hero achilles("Achilles", 20, 6); 
    Hero hector("Hector", 30, 5); 
    Hero atalanta("Atalanta", 10, 3); 
    Hero hippolyta("Hippolyta", 10, 2); 

    cout << endl << "Quarter Finals" << endl; 
    const Hero& greek_winner0 = moneyhunger * hector; 
    const Hero& greek_winner1 = achilles * hector; 
    const Hero& greek_winner2 = hercules * theseus; 
    const Hero& greek_winner3 = oddyseus * ajax; 
    const Hero& greek_winner4 = atalanta * hippolyta; 

    cout << endl << "Semi Finals" << endl; 
    const Hero& greek_winner_semifinal1 = greek_winner1 * greek_winner2; 
    const Hero& greek_winner_semifinal2 = greek_winner3 * greek_winner4; 

    cout << endl << "Finals" << endl; 
    greek_winner_semifinal1 * greek_winner_semifinal2; 
    system("pause"); 
    return 0; 
} 

Answer 1

오퍼레이터 *this를 반환하고 Hero& 반환형을 가질 필요가있다. 또한 논리 오류가 있기 때문에 else 문을 사용해야합니다.

Answer 2

당신은 가끔 한 번 이상 건강을 줄일 기능을

void Hero::operator-=(int attack) { 
    if (attack > 0) { 
     m_health -= attack; 
    } 
    if (attack > m_health) { 
     m_health = 0; 
    } 
} 

이 있습니다.

한다고 가정 건강은 15이며, 문은 5.에 건강을 줄일 두 번째 경우 문은 다음이 당신이 할 수있는 방지하기 위해 0

에 다시 줄일 공격은 첫 번째 10입니다 :

void Hero::operator-=(int attack) { 
    if (attack > 0) { 
     if (attack > m_health) { 
      m_health = 0; 
     } else { 
      m_health -= attack; 
     } 
    } 
} 

이렇게하면 공격이 나머지 건강 상태보다 큰 경우에만 상태가 0으로 줄어 듭니다.