Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?

Tworzenie obiektów klasy za pomocą pętli

Ostatnio zmodyfikowano 2014-11-23 12:49
Autor Wiadomość
Heisenberg
Temat założony przez niniejszego użytkownika
Tworzenie obiektów klasy za pomocą pętli
» 2014-11-21 17:49:25
Czy da się za pomocą pętli lub w jakikolwiek inny sposób stworzyć kilka obiektów klasy,które różnią się jednym parametrem  bo mam ich 40 a ręczna definiowanie wygląda trochę nieestetycznie.
P-121115
Monika90
» 2014-11-21 17:51:22
Da się. std::vector i push_back()
P-121116
michal11
» 2014-11-21 19:08:24
emplace_back() też się może przydać.
P-121119
Heisenberg
Temat założony przez niniejszego użytkownika
» 2014-11-21 19:29:56
C/C++
#define _USE_MATH_DEFINES
#include <allegro.h>
#include <cmath>
#include <iostream>
#include <vector>

using namespace std;

class Planeta {
public:
    Planeta() {
        rPlanety = 10;
        r = 75;
        theta = 0;
        xc = 500;
        yc = 350;
    }
    Planeta( int rPlanety, double r, double theta, int xc, int yc ) {
        this->rPlanety = rPlanety;
        this->r = r;
        this->theta = theta;
        this->xc = xc;
        this->yc = yc;
       
    }
   
    void rysuj( BITMAP * bufor ) {
        int x =( int )( r * cos( theta ) + xc );
        int y = floor( r * sin( theta ) + yc );
       
        circlefill( bufor, x, y, rPlanety, makecol( 255, 255, 255 ) );
    }
   
   
   
   
    void obroc( const double & dTheta ) {
       
        theta = theta + dTheta;
       
    }
   
    double pobierzR() { return r; }
    double pobierztheta() { return theta; }
    double pobierzXC() { return xc; }
    double pobierzYC() { return yc; }
    double pobierzRP() { return rPlanety; }
   
   
   
   
private:
    double rPlanety;
    double r;
    double theta;
    int xc;
    int yc;
};

class PlanetaKolorowa
    : public Planeta
{
public:
    PlanetaKolorowa( int rPlanety, double r, double theta, int xc, int yc, int czerwony, int zielony, int niebieski )
        : Planeta( rPlanety, r, theta, xc, yc )
    {
        this->czerwony = czerwony;
        this->zielony = zielony;
        this->niebieski = niebieski;
    }
   
   
    void rysuj( BITMAP * bufor ) {
        int x =( int )( pobierzR() * cos( pobierztheta() ) + pobierzXC() );
        int y = floor( pobierzR() * sin( pobierztheta() ) + pobierzYC() );
        circlefill( bufor, x, y, pobierzRP(), makecol( czerwony, zielony, niebieski ) );
    }
   
private:
    int czerwony;
    int zielony;
    int niebieski;
   
};

volatile int ticks = 0;
void ticker()
{
    ticks++;
}
END_OF_FUNCTION( ticker )

const int updates_per_second = 60;

const int W = 1000;
const int H = 700;

int main()
{
   
   
    allegro_init();
    install_keyboard();
    set_color_depth( 32 );
    set_gfx_mode( GFX_AUTODETECT_WINDOWED, W, H, 0, 0 );
    BITMAP * bufor = NULL;
    bufor = create_bitmap( W, H );
   
    double omega = 2 * M_PI / 5;
   
   
   
    Planeta p1;
    Planeta p2( 10, 75, 2 * M_PI / 11, 500, 350 );
    Planeta p3( 10, 75, 4 * M_PI / 11, 500, 350 );
    Planeta p4( 10, 75, 6 * M_PI / 11, 500, 350 );
    Planeta p5( 10, 75, 8 * M_PI / 11, 500, 350 );
    PlanetaKolorowa p6( 10, 75, 10 * M_PI / 11, 500, 350, 0, 255, 0 );
    Planeta p7( 10, 75, 12 * M_PI / 11, 500, 350 );
    Planeta p8( 10, 75, 14 * M_PI / 11, 500, 350 );
    Planeta p9( 10, 75, 16 * M_PI / 11, 500, 350 );
    Planeta p10( 10, 75, 18 * M_PI / 11, 500, 350 );
    Planeta p11( 10, 75, 20 * M_PI / 11, 500, 350 );
   
    Planeta pp1( 15, 125, 0, 500, 350 );
    Planeta pp2( 15, 125, 2 * M_PI / 11, 500, 350 );
    Planeta pp3( 15, 125, 4 * M_PI / 11, 500, 350 );
    Planeta pp4( 15, 125, 6 * M_PI / 11, 500, 350 );
    Planeta pp5( 15, 125, 8 * M_PI / 11, 500, 350 );
    Planeta pp6( 15, 125, 10 * M_PI / 11, 500, 350 );
    PlanetaKolorowa pp7( 15, 125, 12 * M_PI / 11, 500, 350, 0, 255, 0 );
    Planeta pp8( 15, 125, 14 * M_PI / 11, 500, 350 );
    Planeta pp9( 15, 125, 16 * M_PI / 11, 500, 350 );
    Planeta pp10( 15, 125, 18 * M_PI / 11, 500, 350 );
    Planeta pp11( 15, 125, 20 * M_PI / 11, 500, 350 );
   
   
    Planeta ppp1( 20, 200, 0, 500, 350 );
    Planeta ppp2( 20, 200, 2 * M_PI / 11, 500, 350 );
    Planeta ppp3( 20, 200, 4 * M_PI / 11, 500, 350 );
    Planeta ppp4( 20, 200, 6 * M_PI / 11, 500, 350 );
    Planeta ppp5( 20, 200, 8 * M_PI / 11, 500, 350 );
    Planeta ppp6( 20, 200, 10 * M_PI / 11, 500, 350 );
    Planeta ppp7( 20, 200, 12 * M_PI / 11, 500, 350 );
    PlanetaKolorowa ppp8( 20, 200, 14 * M_PI / 11, 500, 350, 0, 255, 0 );
    Planeta ppp9( 20, 200, 16 * M_PI / 11, 500, 350 );
    Planeta ppp10( 20, 200, 18 * M_PI / 11, 500, 350 );
    Planeta ppp11( 20, 200, 20 * M_PI / 11, 500, 350 );
   
    Planeta pppp1( 25, 300, 0, 500, 350 );
    Planeta pppp2( 25, 300, 2 * M_PI / 11, 500, 350 );
    Planeta pppp3( 25, 300, 4 * M_PI / 11, 500, 350 );
    Planeta pppp4( 25, 300, 6 * M_PI / 11, 500, 350 );
    Planeta pppp5( 25, 300, 8 * M_PI / 11, 500, 350 );
    Planeta pppp6( 25, 300, 10 * M_PI / 11, 500, 350 );
    Planeta pppp7( 25, 300, 12 * M_PI / 11, 500, 350 );
    Planeta pppp8( 25, 300, 14 * M_PI / 11, 500, 350 );
    PlanetaKolorowa pppp9( 25, 300, 16 * M_PI / 11, 500, 350, 0, 255, 0 );
    Planeta pppp10( 25, 300, 18 * M_PI / 11, 500, 350 );
    Planeta pppp11( 25, 300, 20 * M_PI / 11, 500, 350 );
   
   
   
   
   
   
    install_timer();
   
   
    LOCK_VARIABLE( ticks );
    LOCK_FUNCTION( ticker );
    install_int_ex( ticker, BPS_TO_TIMER( updates_per_second ) );
   
    bool quit = false;
   
    while( !quit )
    {
        while( ticks == 0 )
        {
            rest( 1 );
        }
       
        while( ticks > 0 )
        {
            int old_ticks = ticks;
           
           
            double dt = 1.0 / updates_per_second;
           
            p1.obroc( omega * dt );
            p2.obroc( omega * dt );
            p3.obroc( omega * dt );
            p4.obroc( omega * dt );
            p5.obroc( omega * dt );
            p6.obroc( omega * dt );
            p7.obroc( omega * dt );
            p8.obroc( omega * dt );
            p9.obroc( omega * dt );
            p10.obroc( omega * dt );
            p11.obroc( omega * dt );
           
            pp1.obroc( omega * dt );
            pp2.obroc( omega * dt );
            pp3.obroc( omega * dt );
            pp4.obroc( omega * dt );
            pp5.obroc( omega * dt );
            pp6.obroc( omega * dt );
            pp7.obroc( omega * dt );
            pp8.obroc( omega * dt );
            pp9.obroc( omega * dt );
            pp10.obroc( omega * dt );
            pp11.obroc( omega * dt );
           
            ppp1.obroc( omega * dt );
            ppp2.obroc( omega * dt );
            ppp3.obroc( omega * dt );
            ppp4.obroc( omega * dt );
            ppp5.obroc( omega * dt );
            ppp6.obroc( omega * dt );
            ppp7.obroc( omega * dt );
            ppp8.obroc( omega * dt );
            ppp9.obroc( omega * dt );
            ppp10.obroc( omega * dt );
            ppp11.obroc( omega * dt );
           
            pppp1.obroc( omega * dt );
            pppp2.obroc( omega * dt );
            pppp3.obroc( omega * dt );
            pppp4.obroc( omega * dt );
            pppp5.obroc( omega * dt );
            pppp6.obroc( omega * dt );
            pppp7.obroc( omega * dt );
            pppp8.obroc( omega * dt );
            pppp9.obroc( omega * dt );
            pppp10.obroc( omega * dt );
            pppp11.obroc( omega * dt );
           
            ticks--;
            if( old_ticks <= ticks )
                 break;
           
        }
       
       
        clear_bitmap( bufor );
       
        p1.rysuj( bufor );
        p2.rysuj( bufor );
        p3.rysuj( bufor );
        p4.rysuj( bufor );
        p5.rysuj( bufor );
        p6.rysuj( bufor );
        p7.rysuj( bufor );
        p8.rysuj( bufor );
        p9.rysuj( bufor );
        p10.rysuj( bufor );
        p11.rysuj( bufor );
       
        pp1.rysuj( bufor );
        pp2.rysuj( bufor );
        pp3.rysuj( bufor );
        pp4.rysuj( bufor );
        pp5.rysuj( bufor );
        pp6.rysuj( bufor );
        pp7.rysuj( bufor );
        pp8.rysuj( bufor );
        pp9.rysuj( bufor );
        pp10.rysuj( bufor );
        pp11.rysuj( bufor );
       
        ppp1.rysuj( bufor );
        ppp2.rysuj( bufor );
        ppp3.rysuj( bufor );
        ppp4.rysuj( bufor );
        ppp5.rysuj( bufor );
        ppp6.rysuj( bufor );
        ppp7.rysuj( bufor );
        ppp8.rysuj( bufor );
        ppp9.rysuj( bufor );
        ppp10.rysuj( bufor );
        ppp11.rysuj( bufor );
       
        pppp1.rysuj( bufor );
        pppp2.rysuj( bufor );
        pppp3.rysuj( bufor );
        pppp4.rysuj( bufor );
        pppp5.rysuj( bufor );
        pppp6.rysuj( bufor );
        pppp7.rysuj( bufor );
        pppp8.rysuj( bufor );
        pppp9.rysuj( bufor );
        pppp10.rysuj( bufor );
        pppp11.rysuj( bufor );
       
       
        blit( bufor, screen, 0, 0, 0, 0, W, H );
       
        if( keypressed() ) quit = true;
       
       
    }
   
    destroy_bitmap( bufor );
    return 0;
}
END_OF_MAIN()

Mam właśnie taki kod i jak to przerobić za pomocą wektora ?
P-121121
NopeDotAvi
» 2014-11-21 19:35:24
C/C++
#include <memory> //dla smart pointerow (c++11)
#include <vector>
// twoj kod

int main()
{
    std::vector < std::shared_ptr < Planeta > > planety; //std::shared_ptr to smart pointer (nie musisz sam dealokowac pamieci)
    for( int i = 0; i < TWOJAILOSCOBIEKTOW; ++i )
    {
        //dodanie do vektora
        planety.push_back( new Planeta( twojeparametry() );
    }
   
}
P-121122
Monika90
» 2014-11-21 19:50:41
std::vector < std::shared_ptr < Planeta > > planety;
Nie ma powodu by używać shared_ptr, jak nie ma powodu by używać shared_ptr to się używa unique_ptr.

C/C++
planety.push_back( new Planeta( twojeparametry() );
}
Tutaj niestety możliwy jest wyciek pamięci.

A tak w ogóle to nie będzie działać poprawnie bo funkcje obroc i rysuj nie są wirtualne.

EDIT: obroc nie musi być wirtualne, ale rysuj musi.
P-121124
NopeDotAvi
» 2014-11-21 20:00:22
uh, racja, zbytnio się zapędziłem.

A czemu uważasz, że grozi wyciek pamięci?
P-121125
Monika90
» 2014-11-21 20:02:50
A czemu uważasz, że grozi wyciek pamięci?
Nie grozi, pomyliłam z emplace_back
P-121126
« 1 » 2
  Strona 1 z 2 Następna strona