//------------------------------------
struct Color15bit{....};
struct Color16bit{....};

//------------------------------------
if( ColorMode == 15 )
    typedef Color15bit Color16;
else if( ColorMode == 16 )
    typedef Color16bit Color16;

//----------------------------------
Color16 aPixel(255, 255, 255 );
//***********************************************//

I know this is impossible

How can I have same effect like that?

Use polymorphism :)
For example:
Abstract class Color with Color specific methods.
Concrete classes Color15 and Color16 deriving from Color and implementing
the interface Color specifies.

Then when you create a specific Color object you can use a ColorFactory, for
example, that creates the right concrete Color
object depending on the ColorMode like:

class Color {...};
class Color15 : public Color {...};
class Color16 : public Color {...};

Color* ColorFactory::MakeColor()
{
    if(ColorMode == 15)
        return new Color15;
    else if(ColorMode == 16)
        return new Color16;

...
Color* aPixel = ColorFactory::MakeColor();
...

This is a very simplistic implementation, but the essence of the concept is
there I think. :)

Regards,
Dadi.

You could use a class hierarchy, such as:

class ColorPixel
{
public:
    ColorPixel(int red, int green, int blue);
    // whatever colors can do

class ColorPixel15 : public ColorPixel
{
public:
    ColorPixel15(int red, int green, int blue) : ColorPixel(red, green,
blue) { }
    // whatever additional things ColorPixel15s can do

class ColorPixel16 : public ColorPixel
{
public:
    ColorPixel16(int red, int green, int blue) : ColorPixel(red, green,
blue) { }
    // whatever additional things ColorPixel16s can do

// somewhere off in code:
ColorPixel* pPixel = NULL;
if (ColorMode == 15)
    pPixel  = new ColorPixel 15;
else if (ColorMode == 16)
    pPixel = new ColorPixel 16;

// etc.