Teen tässä tämmöstä pientä ohjelmaa joka simuloi "kohteiden" elämää määrätyn kokoisella alueella.
Ongelmana on se että kun kaksi "kohdetta" parittelee niin homma jökkää.
Debuggeri sanoo: "Access violation writing location 0x5a9be984."
ja osoittaa riviä 189 OBJECT.h:ssa.
tolla ois lähde koodit:
http://user.personal.fi/atk/Lahha/source/
Ongelmana on se että kun kaksi "kohdetta" parittelee niin homma jökkää.
Debuggeri sanoo: "Access violation writing location 0x5a9be984."
ja osoittaa riviä 189 OBJECT.h:ssa.
tolla ois lähde koodit:
http://user.personal.fi/atk/Lahha/source/
Vastaukset 5
Vanhimmat
tuo olio kuulu luoda konstruktorin kautta?
OBJECT* temp = new OBJECT;
OBJECT* temp = new OBJECT(); ??
Mutta eikös nämä ole täsmälleen samat
OBJECT* temp = new OBJECT;
OBJECT* temp = new OBJECT();?
Sulut tarvitaan vasta sitten jos halutaan välittää parametreja konstruktorille. Tosin monet käyttävät sulkuja silti vaikka parametrejä ei ole, yhtenäistää koodia, makuasia.
Siitä on aikaa kun itse C :llä ohjelmoin, tuon tapainen virheilmoitus tuli silloin kun ylitti muuttujan lukualueen. Ratkaisuna oli kasvattaa muuttujan lukualuetta, siis int -> long int -> long long int
Luokkamäärittelyt on tehty C :n yleisten ohjeiden vastaisesti. Muutama aihe aiemmin joku kyseli koodiprojektin aloitukseen vinkkejä:
http://keskustelu.suomi24.fi/show.fcgi?category=108&conference=4500000000000140&posting=22000000021958251
Käytä tuota ohjetta ja muuta koodia:
1. Vain luokan määrittelyt tehdään h -tiedostoissa
2. Jäsenmuuttujat sijoitetaan protect tai private -osaan
3. Alusta AINA jäsenmuuttujat luokkamäärittelyissä (OBJECT.h:n rivillä 189 on objects[t->x][t->y]=t; Esimerkkiajossa t->x=-842150451 ja t->y=-842150451)
Käytä esim. seuraavaa pohjaa h-tiedostoille (korvaa XX luokan nimellä):
//XX class template
//Add usage here
#ifndef XX_h
#define XX_h
// SYSTEM INCLUDES
//
// PROJECT INCLUDES
//
// LOCAL INCLUDES
//
// FORWARD REFERENCES
//
class XX
{
public:
// LIFECYCLE
// Default constructor
XX(void);
// Copy constructor
// from - The value to copy to this object
XX(const XX& from);
// Destructor
~XX(void);
// OPERATORS
// Assignment operator.
// from - value to assign to this object.
XX& operator=(XX& from);
// OPERATIONS
// ACCESS
// INQUIRY
protected:
private:
};
// INLINE METHODS
//
// EXTERNAL REFERENCES
//
#endif // _XX_h_
cpp -tiedoston pohja voisi olla:
//Add usage here
#include "XX.h" // class implemented
/////////////////////////////// PUBLIC ///////////////////////////////////////
//============================= LIFECYCLE ====================================
XX::XX()
{//ALUSTA JÄSENMUUTTUJAT TÄSSÄ
}// XX
XX::XX(const XX&)
{
}// XX
XX::~XX()
{
}// ~XX
//============================= OPERATORS ====================================
XX&
XX::operator=(XX&);
{
return *this;
}// =
//============================= OPERATIONS ===================================
//============================= ACCESS ===================================
//============================= INQUIRY ===================================
/////////////////////////////// PROTECTED ///////////////////////////////////
/////////////////////////////// PRIVATE ///////////////////////////////////
Vikana oli kun funktiossa :OBJECT* AddObject(OBJECT *mom, OBJECT *dad)
kohta
while(EchoMap(temp->x, temp->y) != NULL)
{
temp->x=0+(rand()%MAP_SIZE_X);
temp->y=0+(rand()%MAP_SIZE_Y);
}
piti olla näin.
do
{
temp->x=0+(rand()%MAP_SIZE_X);
temp->y=0+(rand()%MAP_SIZE_Y);
}while(EchoMap(temp->x, temp->y) != NULL);
Kun se tuossa ekaas tarkistaakin nuo alustamattomat arvot.
EMpä nyt viitsi tuollaista hupi koodia kirjoittaa kokonaan uusiksi vain siksi että sen joidenkin yleisten ohjeiden vastainen
Tuo että jäsenmuuttujia ei ole alustettu, on aika yleinen ongelma. Usein se tulee vastaan, kun käytetään 'epästandardeja' kirjoittamistapoja. Yleisten ohjeiden tarkoituksena on vähentää virhetilanteita eli tehdään kaikki varmanpäälle.
Koodin järjestely puolestaan parantaa luettavuutta. Sellainen, joka ei ole nähnyt koodia aiemmin, löytää nopeammin haluamansa tiedon.
Kannattaa opetella tuon käyttöä tosin kenties vähän pienemmällä koodilla.