C: Bitoperationen - Zugriff aus LSB

Moin,

angenommen ich möchte einen Algorithmus, wie "Square-and-Multiply" schreiben, der ja auf der Bit-Zerlegung der Potenz basiert. Sagen wir einfach a^b mod p.

Die Zahl b=(b_n,...,b_0) mit b=summe(b_k2^k) liegt als Hex im Speicher. Wie lassen sich die Bit-Operationen von C nutzen, um diese Bits, ohne sie zu kennen, durchzugehen und gemäß des Algorithmus zu verwenden?

Ich würde immer die letzte Stelle der Binärdarstellung betrachten und einen Rightshift durchführen. Allerdings müsste dann das Programm wissen, dass ich hier binär durchgehe und die Zahl nicht als Charakter betrachten möchte. Bzw. einfach nur das LSB ausgeben lassen. Wie kann ich das realisieren?

Also sagen wir, wir betrachten den nachfolgenden "stümperhaften" Programmablauf :) Aber kürzer bekomme ich das nicht unbedingt hin.

Code:
#include <time.h> //für Zeitstempel und Initialisierung des Zufallsvektors
#include <stdlib.h> // Funktion rand()
#include <stdint.h> // Datentyp uint32_t

void main
{
    srand(time(NULL));    
    uint32_t b = rand() % 17; //Größe von 17 reicht vollkommen..

    do{
        print( (b >> 1) & 1 );
    }while( b >>= 1 );

}

So klappt es. Gelöst :D

Ich wusste nicht, dass ( b >> 1 ) & 1; so "mächtig" ist.
 
Zuletzt bearbeitet:
Erweiterte Fragestellung: Wie kann ich den gesamten Bit-Strom in einem Charakter abspeichern? Oder die Ausgabe in einer Zeile erzeugen?

M(n)WE [Minimal (not) Working Example]

Code:
void print_test(const char *text)
{
    unsigned char output[200];

    sprintf((char*)output, "%s", text); //wandelt ganzen Char-Array durch %s um.
    // print(output); ich übergebe das ganze an den USART), gibt nichts aus.
}

void main()
{
    int a=27, t=a, k=0;
    char bin[27];
	
    bin[0] = '0'; bin[1] = '\0';
    print_test(&bin[0]); //Übergabe der ersten Adresse
}
 
Zuletzt bearbeitet:
Ich verstehe noch nicht genau, was du eigentlich willst.
Und deine Funktion wandelt überhaupt nichts um. Um zwischen signed und unsigned char zu wechseln, kannst du einfach casten - dazu musst du nicht das ganze Char-Array kopieren.
Und
Code:
&bin[0]
ist ebenfalls quasselnder Code - stattdessen kannst du einfach
Code:
bin
übergeben. Das ist dann ein Zeiger auf das nullte Element des Arrays.
Vielleicht kannst du noch mal erläutern, was du eigentlich erreichen willst.

Viele Grüße,
Pik-9
 
Ich will den Bitstream in einer Zeile ausgeben lassen. Aktuell wird je Zeile ein Zeichen ausgegeben. Ein char *text = "Hallo Welt" lässt sich ohne Probs in einer Zeile ausgeben. Aber sobald ich char text[ZAHL] mache, und text[0] , ... ,text[ZAHL-1] belegen will ist vorbei.
 
Ich will den Bitstream in einer Zeile ausgeben lassen. Aktuell wird je Zeile ein Zeichen ausgegeben.
Vielleicht so?
Code:
#include <stdint.h>                                                                                                 
#include <limits.h>                                                                                                 
#include <stdio.h>                                                                                                  
                                                                                                                    
#if (CHAR_BIT != 8)                                                                                                 
#error "CHAR_BIT != 8"                                                                                              
#endif                                                                                                              
                                                                                                                    
#define BUF_LEN 6                                                                                                   
                                                                                                                    
void print_bits(char byte) {                                                                                        
    for (int pos = CHAR_BIT-1; pos >= 0; --pos) {                                                                   
        fputs(                                                                                                      
              byte & (1 << pos) ? "1" : "0",                                                                        
              stdout                                                                                                
             );                                                                                                     
    }                                                                                                               
}                                                                                                                   
                                                                                                                    
int main(void)                                                                                                      
{                                                                                                                   
    char bit_stream[BUF_LEN] = {1,3,3,7,0,-1};                                                                      
    for (int i = 0; i < BUF_LEN; i++) {                                                                             
        print_bits(bit_stream[i]);                                                                                  
        puts("");                                                                                                   
    }                                                                                                               
    return 0;                                                                                                       
}
Code:
% ./a.out                                     
00000001
00000011
00000011
00000111
00000000
11111111


Ein char *text = "Hallo Welt" lässt sich ohne Probs in einer Zeile ausgeben. Aber sobald ich char text[ZAHL] mache, und text[0] , ... ,text[ZAHL-1] belegen will ist vorbei.
char *text = "hello" ist ja auch ungleich char text[] = "hello".
Im ersten Fall ist es nur ein Zeiger auf ein Stringliteral irgendwo im Speicher. I.d.R (mittlerweile) nur readonly.
Im zweiten Fall wird ein Array angelegt und das Literal kopiert.
 
Zurück
Oben