Can't redraw an image in space - c++

Question

I am getting some practice with SDL. I currently am drawing space with classes star, sun, and earth. I can get everything to render to the screen but when I move the sun with the right arrow key, I can't figure out how to delete the old sun to simulate that the view is rotating around the sun. It just creates a big line across the screen. I think I need to clear the screen, redraw the stars, sun, and earth every time the key is down. However, I can't redraw the stars because they fall out of scope and if I recreate them they will be in a different position since I use rand() to randomize their locations. I have hit a big wall and would appreciate any advice.
The code:
// Planet.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <SDL.h>
#include <SDL_gfxPrimitives.h>
#include <stdlib.h>
#include <time.h>
class Star
{
private:
int x,y,rad,r,g,b,a;
SDL_Surface* screen;
public:
Star(SDL_Surface* sc, int xx, int yy, int ra, int rr, int gg, int bb, int aa){screen=sc;x=xx;y=yy;rad=ra;r=rr;g=gg;b=bb;a=aa;}
~Star(){}
void Show()
{
filledCircleRGBA(screen, x, y, rad, r, g, b, a);
}
};
class Sun
{
private:
int x,y,rad,r,g,b,a;
SDL_Surface* screen;
public:
Sun(SDL_Surface* sc, int xx, int yy, int ra, int rr, int gg, int bb, int aa){screen=sc;x=xx;y=yy;rad=ra;r=rr;g=gg;b=bb;a=aa;}
~Sun(){}
void Show()
{
for (int light=10;light<241;light+=10){
filledCircleRGBA(screen, x, y, rad+(light/7), r, g, b+(light/2), a-light);
}
}
void Move(int a, int b)
{
x+=a;
y+=b;
}
};
class Earth
{
private:
int x,y,rad,r,g,b,a;
SDL_Surface* screen;
public:
Earth(SDL_Surface* sc, int xx, int yy, int ra, int rr, int gg, int bb, int aa){screen=sc;x=xx;y=yy;rad=ra;r=rr;g=gg;b=bb;a=aa;}
~Earth(){}
void Show()
{
for (int light=10;light<241;light+=10){
filledCircleRGBA(screen, x, y, rad+(light/7), r, g, b+(light/2), a-(light/2));
}
for (double light=0;light<.25;light+=.01){
filledEllipseRGBA(screen, x, y-(rad*1.05), rad*(.60+light), rad*(.1+light), 170+(light*100), 170+(light*100), 170+(light*100), 255-(light*1000));
}
}
};
int main( int argc, char* args[] )
{
//Start SDL
SDL_Init( SDL_INIT_EVERYTHING );
SDL_Surface* screen = NULL;
screen = SDL_SetVideoMode( 1366, 768, 32, SDL_FULLSCREEN | SDL_SWSURFACE);
srand((unsigned)time(NULL));
//Stars
for (int x=0;x<1361;x+=25){
for (int y=0;y<766;y+=25){
int Special = rand()%3;
if(Special==0||Special==1){
Star star(screen, x+(rand()%30), y+(rand()%30), 0+(rand()%1), 235+rand()%21, 235+rand()%21, 235+rand()%21, 205+rand()%51);
star.Show();
}
if(Special==2){
Star star(screen, x+(rand()%30), y+(rand()%30), 0+(rand()%2), 235+rand()%21, 235+rand()%21, 235+rand()%21, 205+rand()%51);
star.Show();
}
}
}
//Sun
Sun sun(screen, 200, 300, 10, 255, 255, 0, 255);
sun.Show();
//Earth
Earth earth(screen, 700, 400, 100, 0, 80, 255, 255);
earth.Show();
SDL_Event event;
bool Running=1;
bool keysHeld[323]={false};
while (Running)
{
// Handle input
if (SDL_PollEvent(&event))
{
if (event.type == SDL_QUIT)
{
Running = false;
}
if (event.type == SDL_KEYDOWN)
{
keysHeld[event.key.keysym.sym] = true;
}
if (event.type == SDL_KEYUP)
{
keysHeld[event.key.keysym.sym] = false;
}
}
if ( keysHeld[SDLK_ESCAPE] )
{
Running = false;
}
if ( keysHeld[SDLK_LEFT] )
{
}
if ( keysHeld[SDLK_RIGHT] )
{
SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
sun.Move(4,0);
sun.Show();
}
if ( keysHeld[SDLK_UP] )
{
}
if (keysHeld[SDLK_DOWN])
{
}
SDL_Flip(screen);
}
//Quit SDL
SDL_Quit();
return 0;
}

Answer 1

EDIT
Since my last answer was rubbish, I try again:
Yes, indeed, the stars are going out of scope since they are declared in the loop. What you could do is to save every star in an array, but this is a huge waste of bytes.
A better approach in my opinion is to draw all stars in a surface, and blit it on the screen every time you need it. This should be fast and memory efficient. I'll sho a short sample:
Uint32 rmask, gmask, bmask, amask;
/* SDL interprets each pixel as a 32-bit number, so our masks must depend
on the endianness (byte order) of the machine */
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
rmask = 0xff000000;
gmask = 0x00ff0000;
bmask = 0x0000ff00;
amask = 0x000000ff;
#else
rmask = 0x000000ff;
gmask = 0x0000ff00;
bmask = 0x00ff0000;
amask = 0xff000000;
#endif
SDL_Surface* star_surface = SDL_CreateRGBSurface(SDL_SWSURFACE, 1361, 766, 32, rmask, gmask, bmask, amask);
And now, you draw your stars into this surface:
...
Star star(star_surface, x+(rand()%30), y+(rand()%30), 0+(rand()%1), 235+rand()%21, 235+rand()%21, 235+rand()%21, 205+rand()%51);
star.Show();
...
Any time you need it, you blit this surface as a background to your screen using this function:
int SDL_BlitSurface(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect);