Terve vaan kaikille!
Olis tämmönen ajatus jostain tulla tupsahtanu, joka ei toimi vaan toimiiko?
Eli mulla ois 2 eri luokkaa ilman mitään periytymistä yms oleellista.
Kummassakin luokassa ois samat ominaisuudet eli 3 integeria.
Class LUOKKA1
{
int luku1, luku2, luku3 ;
}
Class LUOKKA2
{
int luku1, luku2, luku3 ;
}
int main()
{
LUOKKA1 luokka_1 ;
LUOKKA2 luokka_2(luokka_2) ;
return 0 ;
}
LUOKKA1:ssa olis vaan konstruktori, joka ottais vastaan olion pääohjelmalta, jonka sisältö tulis LUOKKA2:n oliosta, jossa konstruktorissa alustettais nämä luku-muuttujat. Vieläkö kärryillä? Mitenkähän tämä on mahdollista vai onko ? No eihän tässä järkee ole, mutta siitä huolimatta tämmönen pähkinä. Toivottavasti se ei ole mahdollinen. Sitten, jos jollain ois osaamista tuon syntaksin kanssa niin olis kiva. Itse just alottelin C :aa ja tulin tuolta java-maailmasta, joten tämä ei nyt niin helppoa ollutkaan.
Olis tämmönen ajatus jostain tulla tupsahtanu, joka ei toimi vaan toimiiko?
Eli mulla ois 2 eri luokkaa ilman mitään periytymistä yms oleellista.
Kummassakin luokassa ois samat ominaisuudet eli 3 integeria.
Class LUOKKA1
{
int luku1, luku2, luku3 ;
}
Class LUOKKA2
{
int luku1, luku2, luku3 ;
}
int main()
{
LUOKKA1 luokka_1 ;
LUOKKA2 luokka_2(luokka_2) ;
return 0 ;
}
LUOKKA1:ssa olis vaan konstruktori, joka ottais vastaan olion pääohjelmalta, jonka sisältö tulis LUOKKA2:n oliosta, jossa konstruktorissa alustettais nämä luku-muuttujat. Vieläkö kärryillä? Mitenkähän tämä on mahdollista vai onko ? No eihän tässä järkee ole, mutta siitä huolimatta tämmönen pähkinä. Toivottavasti se ei ole mahdollinen. Sitten, jos jollain ois osaamista tuon syntaksin kanssa niin olis kiva. Itse just alottelin C :aa ja tulin tuolta java-maailmasta, joten tämä ei nyt niin helppoa ollutkaan.
Vastaukset 8
Vanhimmat
Eli luokan LUOKKA1 konstruktorin parametrina olisi yksi LUOKKA2 olio.
//Luodaan luokat
class LUOKKA1
{
public:
int luku1, luku2, luku3;
LUOKKA1(LUOKKA2 olio2);
};
class LUOKKA2
{
public:
int luku1, luku2, luku3;
};
//LUOKKA1n konstuktori
LUOKKA1::LUOKKA1(LUOKKA2 olio2)
: luku1(olio2.luku1), luku2(olio2.luku2), luku3(olio2.luku1)
{ }
tuollaisessa järjestyksessä, samassa headerissa määriteltynä. Tuossa tulisi joko määritellä luokat erillisissä headereissa esim: Luokka1.h, Luokka2.h, minkä jäljestä Luokka1.h: ssa inclutoidaan Luokka2.h tai sitten pitää samassa headerissa esim: Luokka1Luokka2.h: ssa ennen LUOKKA1-määrieetlyä kertoa kääntäjälle LUOKKA2 on luokka, joka määritellään myöhemmin eli LUOKKA2 tulee esitellä ennen LUOKKA1 esittelymäärittelyä, mikäli sitä aiotaan LUOKKA1: n määrittelyssä käyttää.
Siis tarkoituksena oli, että luokat eivät tiedä toisistaan mitään, mutta ominaisuudet ovat melkein tai täysin samanlaiset molemmilla.
Esittelyt on kyllä keksitty
eli:
class Luokka2;
class Luokka1
{
public:
inline Luokka1(const Luokka2 &aLuokka);
int arvo1, arvo2, arvo3;
};
class Luokka2
{
public:
int arvo1, arvo2, arvo3;
};
Luokka1::Luokka1( const Luokka2 &aLuokka)
: arvo1(aLuokka.arvo1), arvo2(aLuokka.arvo2),
arvo3(aLuokka.arvo3)
{
}
Kauheasti järkeähän tässä ei ole ja sika huonoa designia, mutta kuiteskin.
Siis luokat eivät tiedä toisistaan mitään mutta haluat alustaa toisen toisella...taitaa olla pieni filosofinen ongelma.
hyvä...hyvä...
enemmän kuin pelkkä filosofinen ongelma!
Seuraavassa on 'sinne päin' -ajatus. Osoittimia käytettäessä voi kopioinnin suorittaa haluamallaan tavalla.
Pääfunktiossa on tiedettävä mistä luokista voi kopioinnin suorittaa. Olen tehnyt vain yhden luokan malliksi, mutta samalla pohjalla voisi tehdä kopioinnin luokkien välillä.
//TIEDOSTO - main.cpp
#include "XX.h"
int main(){
XX test, test2;
test.muutasisaltoa(1,2,3);
test2 = &test; //Jos test on erityyppinen kuin test2, käytä castia
return 0;
}
//TIEDOSTO - XX.cpp
#include "XX.h" // class implemented
/////////////////////////////// PUBLIC ///////////////////////////////////////
//============================= LIFECYCLE ====================================
XX::XX()
{
memset(this,0,sizeof(XX));
}// XX
XX::XX(const XX&)
{
}// XX
XX::~XX()
{
}// ~XX
//============================= OPERATORS ====================================
XX& XX::operator=(XX*from)
{
memcpy(this,from,sizeof(XX));
return *this;
}// =
//============================= OPERATIONS ===================================
void XX::muutasisaltoa(int i1,int i2,int i3)
{
luku1=i1,luku2=i2,luku3=i3;
}
//============================= ACCESS =======================================
//============================= INQUIRY ======================================
/////////////////////////////// PROTECTED ////////////////////////////////////
/////////////////////////////// PRIVATE //////////////////////////////////////
//TIEDOSTO - XX.h
//XX class template
//Add usage here
#ifndef XX_h
#define XX_h
// SYSTEM INCLUDES
//
#include
// 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
void muutasisaltoa(int i1,int i2,int i3);
// ACCESS
// INQUIRY
protected:
private:
int luku1,luku2,luku3;
};
// INLINE METHODS
//
// EXTERNAL REFERENCES
//
#endif // _XX_h_