ich habe hier ein Problem,eine intger Array in unsigned char zu
konvertieren. der kompiler meldet keine
fehler aber die char arry bleibt immer leer.
ich hab erstmal versucht,einen unsigned char pointer auf den int pointer zeigen lassen und dann die werte Byte zu Byte in char Array zu kopieren aber die Casting funktioniert nicht richtig.
hier ist mein Code:

int samples   = 100;
        int bitrange   = 16;

        int  val  = 0;
        int* pVal = 0;
        unsigned char  byte  = 0;
        unsigned char* pByte = 0;

        int *intBuf            = new  int[samples]; 
        unsigned char *charBuf = new unsigned char[samples*bitrange/8]; 
          int i,x,j;
           for(i=0,x=0;i<samples;i++)
       {      int y=pow(2,bitrange)-1;
                  intBuf[i]=(int)y*sin(i*2*3.14/samples);

                  val = intBuf[i]; 
                  pVal = &val; 
          //einen unsigned char pointer auf den int pointer zeigen lassen
                  pByte = reinterpret_cast<unsigned char*>(pVal);     
                //std::cout<<"charByte="<<*pByte<<""<<"pval="<<*pVal<<std::endl;
                  // das byte im buffer speichern            
               for(j=0; j<(int)bitrange/8; j++, pByte++)      
                    {  // das byte im char buffer speichern
                        charBuf[x] = *pByte;               

        std::cout<<"x="<<x <<"charbuf="<<charBuf[x]<<""<<"intBuf="<< intBuf[i]<<std::endl;
                   x++;
                   }

            }

          delete [] intBuf;          
          delete [] charBuf;
 return 0;

hier ist Teil der Ausgabe

x=0charbuf=intBuf=0
x=1charbuf=intBuf=0
charByte=pval=4112
x=2charbuf=intBuf=4112
x=3charbuf=intBuf=4112
charByte=pval=8209
x=4charbuf=intBuf=8209
x=5charbuf= intBuf=8209

ich hoffe dass, jemand mir weiterhelfen kann.
danke schönmal im voraus.
Gruß
Salima

Wichtig: Was hältst du eigentlich von folgendem Thread?
http://www.c-plusplus.net/forum/p2184977

// Bitte beachte: Das sind fiktive Zahlen, der Standard definiert diese Größen nicht exakt.
// (Außer dass char genau 1 Byte groß ist.)
[][][][][][][][] // Der Speicher
int* p = (int*)2; // Zeigt jetzt auf das 3. Byte (Natürlich schlechte Idee in richtigem Code. ;))
std::cout << *p; // Liest das 3.und 4. Byte aus, da integer 2 Byte groß sind.
++p; // Zeigt jetzt auf das 5.Byte!
unsigned char* q = p; // Zeigt immer noch auf das 5. Byte
std::cout << *q; // Liest das 5. Byte aus, da unsigned char 1 Byte groß ist.
++q; // q zeigt jetzt auf das 6. Byte

Ich hoffe dir ist jetzt klar, warum so ein reinterpret_cast hier eine schlechte Idee ist.

std::vector<int> v(100); // 100 ints
std::vector<unsigned char> v2(100); // 100 unsigned chars

for (int i = v.size(); i-- != 0; )
{
  v2[i] = v[i];
}

So einfach geht das.

leider so einfach ist es nicht.
char vektor muss in diesem fall doppelt so größe wie das int Vektor und hab was du vorgeschlagt probierst leider besteht immer noch das gleiche problem

std::vector<int> intBuf(samples); 
  std::vector<unsigned char> charBuf(samples);
  int i,x,j;
           for(i=0,x=0;i<samples;i++)
 {      int y=pow(2,bitrange)-1;
        intBuf[i]=(int)y*sin(i*2*3.14/samples);
}

  for (int i = intBuf.size(); i-- != 0; )
{
    charBuf[i]= intBuf[i];
   std::cout<<"i="<<i <<"charbuf="<<charBuf[i]<<""<<"intBuf="<< intBuf[i]<<std::endl;
} 

        //  delete [] intBuf;          
         // delete [] charBuf;
 return 0;

sad was raus kommt:

i=99charbuf=intBuf=-4321
i=98charbuf= intBuf=-8416
i=97charbuf=BintBuf=-12478
i=96charbuf=�intBuf=-16491
i=95charbuf=)intBuf=-20439
intBuf=-24307
i=93charbuf=RintBuf=-28078
..

int main()
{
	const std::size_t size = 100;
	std::vector<int> int_buf(size);
	std::vector<unsigned char> char_buf(size);

	for(std::size_t i = 0; i != size; ++i)
	{
		int_buf[i] = i;
	}

	for (int i = int_buf.size(); i-- != 0; )
	{
		char_buf[i] = static_cast<unsigned char>(int_buf[i]);
		std::cout << i << ": " << static_cast<unsigned int>(char_buf[i]) << '\n';
	}
}

Edit:
end iterator fixed

Soll das ein Witz sein? Der char vector ist danach 4 mal so groß, und das was da passiert ist letztlich memcpy().

Jau, allerdings ist das genau die Anforderung, die TE gefordert hat. Wenn er einfach nur einen Zeiger auf den Speicherbereich haben will kann er ab Zeile 12 aufhören. Was weiß ich, was er mit dem Vektor vorhat, da fehlen einfach Informationen.

Edit:
Und nein, das ist kein Witz

std::vector<unsigned char> char_buf(int_buf.size() * sizeof(int_buf[0]));
std::memcpy(&char_buf[0], &int_buf[0], char_buf.size());