Ich hab folgendes Problem:
Ich habe einen Buffer mit verschiedenen Werten drin:

Buffer[] = {3,9,4,5...}

Diese geben die Anzahl 1 oder 0 an welche ich in einen Datastream umwandeln muss. Also:
z.B

Buffer[0]=3

Ob es nun drei 1 oder drei 0 sind ist im Moment egal. Sagen wir einfach es sind drei 1.
Der Datastream ist 8 bit lang und ist auch ein Buffer.
Also:

Datastream[] = {111xxxxx}
               {xxxxxxxx}
               ...

Ich habe keine Ahnung wie ich das realisieren soll, denn die Werte welche im Buffer stehen, können alle länger als 8 sein.
Weiss jemand wie ich hier vorgehen könnte? Vielen Dank.

Ich hab ehrlich gesagt keine Ahnung was du da vorhast.

Also wenn ich zum Beispiel im Buffer solche Werte habe:
3,2,9,4,6,8...
dann soll im anderen Buffer (Datastream) das gepeichert werden:

Datastream[0]= 11100111
Datastream[1]= 11111100
Datastream[2]= 00111111
Datastream[3]= 00000000

Skym0sh0 schrieb:

Ich hab ehrlich gesagt keine Ahnung was du da vorhast.

Also wenn ich zum Beispiel im Buffer solche Werte habe:
3,2,9,4,6,8...
dann soll im anderen Buffer (Datastream) das gespeichert werden:

Datastream[0]= 11100111
Datastream[1]= 11111100
Datastream[2]= 00111111
Datastream[3]= 00000000

drei mal ne 1, dann 2 mal ne 0, dann 9 mal ne 1 etc.

Naja, sagen wir mal dir reichen als Zielwerte 0 oder 1, dann kannst du den boolschen Datentyp nehmen.

Ich würde dann zuerst anfangen mir einen Vector durchgehend zu befüllen und den danach in eine gewünschte Größe aufsplitten.

Etwa so:

int Buffer[] = {3, 2, 9, 4 /*...*/};

std::vector<bool> tempStream;

// Stream füllen
bool val = true;
for(int i : Buffer)
{
	tempStream.insert(std::end(tempStream), i, val);
	val = !val;
}

// DataStream erzeugen durch splitten des Streams
int chunksize = 8;
std::vector<std::vector<bool>> datastream;
for(int i = 0; i < tempStream.size(); i +=chunksize)
{
	std::vector<bool> tmp;
	for(int j = i; j < i+chunksize, j < tempStream.size(); ++j)
	{
		tmp.push_back(tempStream[j]);
	}
	datastream.push_back(tmp);
}

Achtung ! Ungetestet und kein schöner Code, ganz im Gegenteil, ziemlich hässlich und sehr spezialisiert sogar
Und nicht effizient, das geht besser

Willkommen im C++-Forum.
Dann meinst Du so was - oder:

#include <iostream>
#include <bitset> // nur für Demo-Zwecke (s.write)

void write( unsigned char byte )
{
    std::cout << std::bitset<8>(byte) << std::endl;
}

int main()
{
    using namespace std;
    int Buffer[] = {3,9,4,5,1,2,3};
    unsigned char datastream=0; // Zeichen im DataStream
    int bitIdx = 0;

    int bit = 1; // starte mit '1'
    for( int l = 0; l < sizeof(Buffer)/sizeof(*Buffer); ++l, bit = 1-bit )
    {
        for( int i=0; i < Buffer[l]; ++i )
        {
            datastream <<= 1;
            datastream |= bit;
            if( ++bitIdx == 8 )   // datastream ist voll
            {
                write( datastream );
                bitIdx = 0;
            }
        }
    }
    if( bitIdx > 0 )
        write( datastream << (8-bitIdx) ); // restliche verbleibende Bits scheiben
    cout << endl;
    return 0;
}

Output:

11100000
00001111
00000100
11100000

(getestet und mittel schöner Code)

Gruß
Werner

@Werner
Ich verstehe nicht ganz was hier die Eintrittsbedingung ist:

for( int l = 0; l < /*sizeof(Buffer)/sizeof(*Buffer)*/; ++l, bit = 1-bit )

SOnst sieht dein Vorschlag ganz gut aus und könnte die fast schon ideale Lösung sein. Danke.

Ich verstehe nicht ganz was hier die Eintrittsbedingung ist:

for( int l = 0; l < /*sizeof(Buffer)/sizeof(*Buffer)*/; ++l, bit = 1-bit )

Der Ausdruck 'sizeof(Buffer)' liefert Dir die Größe in Byte, die der Buffer belegt. Da er 7 int-Werte enthält und jeder int-Wert (in einer 32bit-Umgebung) 4 Byte groß ist, sollte das 4*7=28 sein. Was man hier haben will, ist aber die Anzahl der int-Werte, so dass die Lauf-variable 'l' von 0 bis 7-1=6 gehen kann. Also wird die Größe durch die Größe eines int-Werts geteilt. Und ein int-Wert ist hier '*Buffer', was der erste Wert im Buffer ist. sizeof(*Buffer) liefert also 4. Und 28/4 macht eben 7, also die Anzahl.

Warum macht man das?
Ein ganz wichtiger Punkt beim Programmieren im Allgemeinen ist das Vermeiden von Redundanzen. Betrachte dazu die Sequenz:

int Buffer[] = {3,9,4,5,1,2,3};
    size_t Anzahl = sizeof(Buffer)/sizeof(*Buffer);

Du kannst jetzt ein Element im Buffer hinzu fügen, ohne etwas anderes ändern zu müssen. Auch kannst Du den Typ der Elemente ändern, ohne auf etwas anderes Rücksicht zu nehmen. Also z.B.:

short Buffer[] = {3,9,4,5,1,2,3,9,1,2,2,2,8};
    size_t Anzahl = sizeof(Buffer)/sizeof(*Buffer);

.. es ist alles noch so wie es sich der Programmierer am Anfang gedacht hat.

Ungünstig wäre z.B.:

const size_t Anzahl = 7;
    int Buffer[Anzahl] = {3,9,4,5,1,2,3};

Fügst Du ein Element hinzu, so musst Du auch die Anzahl ändern. Vergisst Du eines von beiden, so macht der Code nicht mehr das, was Du denkst. Die 7 ist redundant zu der Anzahl der Elemete.

Gruß
Werner