Konvertierung von intger Arry zu unsigned char Arry

hallo zusammen,

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

SeppJ

Wichtig: Was soll mit den Werten hinterher geschehen?
Warum benutzt du keine std::vector?
Woher kommen die magischen Zahlen? Die passen, wenn ich das richtig sehe auch gar nicht zueinander, sofern sizeof(int) nicht 2 ist, was sehr ungewöhnlich wäre.
Was sollen die ganzen unnötigen Casts, Hilfsvariablen, Zwischenschritte und inkonsistene Benutzung der Kontrollstrukuren? Ist das Programm sauberer geschrieben, dann funktioniert es erfahrungsgemäß auch eher auf Anhieb.
Hast du mal den Kontrollfluss auf dem Papier und im Debugger nachvollzogen und verglichen? Da macht garantiert einiges (eigentlich fast alles) nicht das, was du denkst, was es macht.

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

cooky451

Du musst dir dafür mal vorstellen wie Pointer funktionieren. Angenommen du hast 8 byte Speicher und ints sind 2 byte groß:

// 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.

hallo cooky451,

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
..

cooky451

Natürlich funktioniert das. Das Problem ist, wenn du einen char ausgibst, wird dieser von der Ausgabe als Buchstabe interpretiert. Das willst du aber nicht, du willst wissen welchen Wert er hat. (Als Zahl.)
Daher musst du vor der Ausgabe nach unsigned int casten:

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';
	}
}

DocShoe

#include <vector>

using namespace std;

int main()
{
   vector<int> iv;
   vector<unsigned char> ucv;

   if( !iv.empty() )
   {
      unsigned char* Buf = reinterpret_cast<unsigned char*>( &iv[0] );
      size_t Size = iv.size() * (sizeof( int ) / sizeof( unsigned char ));

      ucv.assign( Buf, Buf + Size );
   }
}

Edit:
end iterator fixed

cooky451

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

DocShoe

cooky451 schrieb:

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

cooky451

Und warum nicht

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