Komisches Logikproblem

Aedyn

Hier mal Code:

main.cpp

//***INCLUDES***//
#include "main.h"
#include <iostream.h>

//***MAIN FUNCTION***//
void main()
{
	Player player;
	Healpotion healpotion;

	cout << "Leben: " << player.health_min << "/" << player.health_max << endl;
	healpotion.use();
	cout << "Leben nach Heiltrank: " << player.health_min << "/" << player.health_max << endl;
}

main.h

#ifndef _MAIN_H_
#define _MAIN_H_

//***INCLUDES***//
#include "player.h"
#include "items.h"

//***VARIABLES, FLAGS & CO.***//

#endif

player.cpp

//***INCLUDES***//
#include "player.h"

//***PLAYER-CLASS***//
Player::Player()
{
	health_min = 400;
	health_max = 500;
}
void Player::addHealth(signed long value)
{
	health_min += value;
}

player.h

#ifndef _PLAYER_H_
#define _PLAYER_H_

//***CLASS PLAYER***//
class Player
{
public:
	Player();

	signed long health_min;
	signed long health_max;

	void addHealth(signed long);
};

#endif

items.cpp

//***INCLUDES***//
#include "items.h"
#include "player.h"
#include <iostream.h>

//***ITEM-CLASSES***//
void Healpotion::use()
{
	Player player;
         player.addHealth(100);
	cout << "Added life!" << endl;
}

items.h

#ifndef _ITEMS_H_
#define _ITEMS_H_

//***CLASS PLAYER***//
class Healpotion
{
public:
	void use();
};

#endif

Nachdem ich healpotion.use() ausgeführt habe, hat health_min immer noch denselben Wert! Dabei sollte dieser um 100 erhöht werden.
Warum passiert das nicht? Die Funktion wird aber durchgelaufen, habe ich getestet!

Wenn ich allerdings statt healpotion.use() lieber player.addHealth(100); schreibe, funktionierts!

Dabei macht healpotion.use() nichts Anderes als player.addHealth(100);

Roar

hab zwar kaum ahnung von c++ aber so wies aussieht erzeugst du in Helpopton#use() ein neue Player instanz, die natürlich eine ander ist als die instanz in deinem hauptprog.
lösung: übergib der methode use() die instanz von Player und benutze diese, also ungefähr so:

void use(Player)

void Healpotion::use(Player player)
{
         player.addHealth(100);
    cout << "Added life!" << endl;
}

healpotion.use(player);

oder so ähnlich :xmas1:
vielleicht musst du auch mit pointern um dich werfen
aber vom prinzip stimmts :xmas2:

Ponto

Jo, du musst natürlich den Player benutzen, der dich interessiert:

void Healpotion::use(Player & player)
{
    player.addHealth(100);
    cout << "Added life!" << endl;
}

Wofür mach ich mir im anderen Thread die Mühe und zeige dir wie es geht, wenn du es dann doch nicht beachtest?

Aedyn

Weil ich es noch nicht richtig verstehe, und erst einmal mit Projekt-Management klar kommen will!

joomoo

bei

void Healpotion::use()
{
    Player player;
         player.addHealth(100);
    cout << "Added life!" << endl;
}

Erstellst du doch einen ganz neuen Player, der wieso nach use() wieder gelöscht wird. Du musst es so wie Ponto machen.

mfg.

Aedyn

Gut, nun funktioniert es und ich verstehe es auch einigermaßen.
Eine Frage noch. Ich erstelle für beinahe jede Klasse eine ".h" und eine ".cpp".
Wenn nun eine Klasse auf die andere zugreifen will, komme ich um #include nicht herum, oder?

Heißt das, ich kann beliebig oft inkludieren, sofern ich den "Wächter" schreibe? (#ifndef -> #define , #endif)

Sicher kannst du beliebig oft inkludieren.

Dabei habe ich noch eine Frage:
ist

#pragma once

Microsoft- oder Standard c++ ?

Das finde ich nämlich hübscher.
In Headern muss man eher selten ein Include schreiben. Da ist eine forward-declaration die bessere wahl. Das geht nur wenn du Referenzen oder Pointer auf andere objekte Benutzt.

joomoo

templäd schrieb:

Sicher kannst du beliebig oft inkludieren.

Dabei habe ich noch eine Frage:
ist
#pragma once
Microsoft- oder Standard c++ ?

Das finde ich nämlich hübscher.
In Headern muss man eher selten ein Include schreiben. Da ist eine forward-declaration die bessere wahl. Das geht nur wenn du Referenzen oder Pointer auf andere objekte Benutzt.

MinGW unterstützt das auch, also ist es nicht nur bei Microsoft Compiliern.

mfg.