In c hexzahl in char arr?

also ich möchte zahlen als maximal 4 stellige hexzahl darstellen

also 10 wäre dann 0x000A

ich möchte das mithilfe der ascii tablee codieren

also wa sich machen würde wäre, ich teile die 10 solange durch 16 bis kein rest mehr da ist oder ich 0 beim teilen rauskriege, also die hexzahl kriege ich raus und dann möchte ich die hexzahl meinetwegen 0x000A in ein char array speichern, dabei soll es aber so sein, dass 2 byte des chararrays nur dafür genutzt werden soll, also deswegen könnte ich halt nur das über die hex ascii zahl machen, also sagen wir ich hab 0x000A dann hab ich 2 teile einmal 00 und 0A jeweils in einem Byte, aber wie wandle ich das um, dass ich dann das character bekomme

das wäre dann ja NUL ^@ für 00 und LF ^J für 0A, ich könnte das alles natürlich in ein array packen und dann jeweils vergleichen und suchen, aber das wäre doch blöd

also wie machen ich das, also kurz ich habe meine beiden teil hexe, also 00 und 0A und will in mein char in ein element NUL ^@ speichenr und in das andere LF ^J, das würde ja so gehen char[0]= 0x00;

hab ich probiert funktioniert, aber wie mach ich das wenn ich das sozusagen in einer variablen habe also 00 in einem char array bzw. 0A

Bild zum Beitrag

1 Antwort

KarlRanseierIII

Von gutefrage auf Grund seines Wissens auf einem Fachgebiet ausgezeichneter Nutzer

Programmiersprache, Programmieren & Softwareentwicklung

30.01.2023, 16:40

Deine Frage ergibt keinerlei Sinn und ist total konfus.

2 Hexstellen repräsntieren einen char, ich kann folgerichtig ein 16-Bit Wort mit 4 Hexstellen repräsentieren. Will ich diese Repräsentation speichern, dann brauche ich einen char je Symbol bei einer ASCII-Kodierung. Nutze ich 2 chars, dann kann ich das 16-Bit Wort darin speichern, zwei aufeinanderfolgende chars sind genau das (vorbehaltlich der Endianess versteht sich).

ulidecktauf

Fragesteller

30.01.2023, 16:46

also ich will nur die länge speichern bzw. ne int zshl

int a = 10;

jetzt will ich ein char array haben, dass diese 10 repräsentiert, natürlich nicht char array = {'1', '0'};

denn so kann ich nur zahlen bis 99 haben, ich möchte aber zahlen der größe irgendwas mit 60000 haben (2^16-1 wegen 0xFFFF, also 65535);

also was ich mir vorgestellt habe wäre

char array = {'NUL ^@','LF ^J'}

ulidecktauf

Fragesteller

30.01.2023, 16:47

@ulidecktauf

weil das wäre ja 0x000A

KarlRanseierIII

30.01.2023, 16:52

@ulidecktauf

Du möchtest also im Endeffekt den 16-Bit Wert in 2 8-Bit Werte teilen?

first=(c & 0xFF00) >> 8;
second=c && 0X00FF;

Was ich hier First udn Second nenne ikönnten auch chars eines Arrays sein.

P.S.: Aber das könntest Du auch je nach Endianess mit eienr direktne Zuweisung erreichen.

ulidecktauf

Fragesteller

30.01.2023, 16:55

@KarlRanseierIII

ok danke, ich prober mit ob ich es implementiert bekomme

also char *array = malloc(sizeof(char)*13);

ich hab dann mit sizeof(array) geguckt und mit printf ausgegben, und siehe da es kommt 8 raus, also wie geht es richtig? anscheinend gibt es hier die bit pro array eintrag aus, hab auch befüllt gehabt, kam das gleiche raus

...zur Frage

[JAVA] Char Array in Int Array umwandeln?

Hallo,

gegeben ist ein Char Array a mit Buchstaben. Diese muss ich sortieren. Wie kann ich den char Array also in einen int Array umwandeln? (Die Buchstaben sollen als ascii Zahlencodes im int Array gespeichert werden.)

Gruß

...zur Frage

Division in Assembly. Zeichen sind in ASCII gespeichert?

section .text
global main

main:
  mov esi, 10           ; ESI holds current number
  mov eax, 0           ; EAX holds sum of numbers
  push 10             ; Line feed for end of line (Stack is first in, last out -> Line feed will be last char)
  mov edi, 10           ; Divisor of 10 for seperating digits of number (used in divisionLoop)



; Sum numbers 1 through 10
sumLoop:
  add eax, esi          ; Add number to sum
  dec esi             ; Next number
  jnz sumLoop           ; Loop until 0



; Seperate eax into its digits, by dividing by 10 multiple times,
; where in each division the remainder will be a single digit 
; and the quotient will be the remaining digits used as dividend in next loop run
divisionLoop:
  mov edx, 0           ; Make sure edx is empty, as it is used as upper half of dividend
  div edi             ; Divide eax by edi (= 10) => quotient is in eax (= Rest of digits for next loop), remainder in edx (= Single digit)
  add edx, 48           ; Make edx (digit) a char representing its value by adding '0' to it
  push edx            ; Push char to stack for usage in print later

  cmp eax, 0           ; Loop until quotient is 0 (=> no more digits left)
  jne divisionLoop



; Print digits from Stack one by one
printLoop:
  mov eax, 4
  mov ebx, 1
  mov ecx, esp          ; Print top of stack (esp always points to top of stack)
  mov edx, 1           ; Length of 1 byte (= 1 char)
  int 80h

  pop esi             ; Remove top of stack
  cmp esi, 10           ; Loop until Line feed is reached
  jne printLoop


exit:
  mov eax, 1
  mov ebx, 0           ; Exit code 0
  int 80h

Hallo,

hier steht ein Programm in Assembler, dass die Zahlen von 1 bis 10 addiert.

Die 55 durch 10 teilt und die Reste der Division dann in einem Stack speichert.

push....

Am Ende wird alles über den Standardkanal ausgegeben auf der Konsole.

Wenn ich 55 / 10 teile ergibt das Quotient 5 steht in Register eax und der Rest hier auch 5 in edx Register. Bevor ich jetzt den Rest auf den Stack lege wird die Zahl mit 48 addiert. ergbit 53 ist das char Zeichen 5 im ASCII Code.

Heißt das jetzt, dass die Ergebnisse bei einer ganzzahligen Division im Assembler-Code immer in ASCII-Zeichen gespeichert sind?

...zur Frage

Python: splitlines trennt nicht nach Zeilenumbruch?

Eine Textdatei mit Steuerzeichen hex 0D 0A 5B 31 als Zeilentrenner protestiert beim Einlesen als Textfile "wt", wenn ich dann die Zeilen lesen will

handle = open("cht.txt", "wt")
lines = handle.readlines()

Fehlermeldung, dass ein gewisses byte nicht eingelesen werden kann.

Wenn ich sie mit "wb" als Binary öffne, dann in ASCII umwandle, bekomme ich eine Datei vom Typ String.

Wende ich dann splitlines auf sie an, kommt nur eine Liste mit einem Element dabei raus.

handle = open("cht.txt", "wb")
chtlines = ascii(handle).splitlines()

Auch wenn ich ein split("\n") verwende, passiert dasselbe.

Warum wird der Zeilenumbruch nicht erkannt.

...zur Frage

C++: Fehler beim schreiben einer .tiff Datei mit Libtiff?

Hi,

das ist hoffentlich meine letzte Frage zu dem Thema :).

Ich habe ein Array mit allen RGBA-Werten für ein Bild im Byte Format (z.B.: 4282989356).
Nun möchte mit diesem Array eine neue Bilddatei vom Format .tiff schreiben und verwende dafür die Bibliothek libtiff.

Ich verwende folgenden Code:

auto image = new uint32[20976 * 20976];
for (uint32 row = 0; row < height; row++)
	{
		TIFFWriteScanline(tif, image, row, 0);
	}

Ich habe hier noch die Dokumentation für TIFFWriteScanline().

Das Programm schreibt eine neue .tif Datei, die sogar eine Dateigröße hat die ich erwarte. Allerdings sieht die Datei geöffnet leider so aus.

Ich bin mir nicht sicher ob ich mein Array einfach so übergeben kann. TIFFWriteScanline() erwartet eine Variable vom Datentyp tdata_t, was auch immer das sein soll.

Es gibt ein Tutorial, welches den Vorgang etwas anders implementiert. Im Tutorial werden ein image und buf Array deklariert, beide vom Typ char.

char *image=new char [width*height*sampleperpixel];
unsigned char *buf = NULL;

Es wird die benötigte Speicher für eine Zeile festgelegt und für buf initialisiert.

tsize_t linebytes = sampleperpixel * width; 
buf =(unsigned char *)_TIFFmalloc(linebytes);

Schließlich wird wie bei mir über jede Zeile iteriert und dabei zunächst die Bilddaten in buf geschrieben und von buf in die .tif Datei.

for (uint32 row = 0; row < h; row++)
{
memcpy(buf, &image[(h-row-1)*linebytes], linebytes);   
TIFFWriteScanline(out, buf, row, 0)
}

Wobei ehrlich gesagt im Tutorial image nur deklariert aber nicht initialisiert wird. Wahrscheinlich muss es noch initialisiert werden. Aber kann ich meine RGBA Daten in Byte codes in ein Char array schreiben? Und wieso werden die Daten überhaupt zuerst in den buf geschrieben? Ist das wichtig und ggf. die Erklärung wieso mein Bild so bescheiden aussieht?
Ich bin gefühlt so kurz vorm Ziel was dieses kleine Projekt angeht und würde mich über Hilfen und Tipps sehr freuen :)

...zur Frage

One-Time-Pad Entschlüsselung?

Sitze gerade an einer Aufgabe, wo ich einen Chiffretext in hex habe und diesen mit zwei Schlüsseln, ebenfalls in hex, mittels OTP entschlüsseln soll. Einer der Klartexte (in ASCII) soll Sinn ergeben. Bei mir kommt aber nur Müll raus.

Kennt sich jemand damit aus?

c= 04 10 12 00 01 08 67 0A 19 65 0F 03 0A 00 (ASCII inHex)
k1= 45 44 46 41 42 43 47 4B 4D 45 4B 42 5D 4E
k2= 45 44 46 41 42 43 47 4B 4D 45 41 4C 45 4E

Meine Vorgehensweise:

ich habe erst mit einem tool c mit k1 entschlüsselt und das ergebnis von HEX zu ASCII konvertiert, dann das selbe mit k2. Raus kommt aber nichts sinnvolles.. wo ist der Fehler?

...zur Frage

Java, programmieren - kann man das irgendwie schöner lösen?

Folgendes ist mein Code:

Kurz zur Erklärung was hier passiert - ein String wird übergeben und der String wird in ein char-Array umgewandelt. Danach wird geprüft, ob im char-Array Vokale vorkommen, jeweils groß- als auch kleingeschrieben. Falls ein Vokal vorkommt, wird die Variable namens length hochgezählt. Diese Variable brauche ich für einen anderen Array, welcher mit der Länge length initialisiert werden muss.

Die Methode aus dem Screenshot funktioniert so wie sie soll, sieht aber nicht unbedingt schön aus, meiner Meinung nach. Nun zur Frage, kann man das irgendwie schöner lösen? 😅

...zur Frage

Probleme mit fgets() in C?

Hallo,

in meinem C Programm hab ich Probleme mit meinem C-Programm. Wenn ich mit fgets() einen string einlese, dann funktioniert das. Beispielsweie "2222". wenn ich jetzt aber strlen(string) anwende, kommt dort 5 raus und nicht 4. Warum ist das so? Ich weiß, fgets() terminiert einen String mit \0, aber strlen() zählt ja ALLE zeichen außer das \0. nimmt fgets() noch das \n mit, wenn ich Enter drücke? Ich weiß, dass ich das Problem einfach mit strlen()-1 lösen kann, aber es geht nicht um das strlen(), sondern darum, dass zwei Strings codiert werden und der code verglichen wird. Einmal wird der String mit fgets() vom Benutzer eingelesen und einmal wird der Code zurückcodiert und dieser String dann wieder codiert, um die beiden codierten Strings auf Fehler zu vergleichen.

...zur Frage

Tabelle mit ASCII-Code in Java

Hallo, Ich soll für den Informatikunterricht eine Tabelle mit den ersten 256 Zeichen des Ascii-Codes mithilfe eines Arrays in Java programmieren, aber ich komm nicht so recht weiter. Die Zahlen werden im Array aber nicht in die Zeichen übersetzt. Ich hab das wie folgt programmiert:

char[ ] asciibyte = new char[256]; int i; char a = 1; for (i = 0; i < asciibyte.length; i++, a++) { asciibyte[i] = a; } System.out.println("Nummer\tZeichen"); for (i = 0; i < asciibyte.length; i++) { System.out.println(i + "\t" + asciibyte + " "); }

Kann mir vielleicht jemand helfen? Ich brauch das bis kommenden Mittwoch.

Danke schon mal im Voraus, benschef

...zur Frage

Kann ich das Programm ohne 2 Schleifen schreiben?

Man kann ja zwei schleifen machen einmal für die jeweilige Zeile und dann für die jeweiligen Spalten bzw Anzahl der Zeichen der Zeile

(Syntax kann falsch sein da ich C lange nicht mehr hatte)

würde es aber auch gehen wenn man ne Schleife macht von i=0 bis i< 5 und dann ein String erstellt und dann pro Durchlauf den String um ein * erhöht

also so char[5] s;

und dann in der Schleife immer um 1 ergänzt

s[i] = ‚*‘;

oder man könnte doch auch mit einem String anfangen der eine Länge von 1 hat und dann die Länge erhöhen und dann immer hinzufügen

und dann den String immer Printen

Also nur aus Interesse

...zur Frage

C: Wie kann ich ein Pointer-Array anlegen, um die Fundstellen zu speichern?

/* 24_02 dynamische Speicherverwaltung
   demonstriert realloc
   ZUR BEACHTUNG: Dies ist ein reines Demo-Programm!
                  Speicher-Reallokation in 10-Byte-Blöcken ist in der Praxis nicht sinnvoll!
                  Speicherallokation und insbesondere Speicher-Reallokation kosten erhebliche System-Resourcen!
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define STRLEN 10

int Such(char* strPtr, char* Ptr2);

int main()
{
  int n = 1;
  char* strPtr = (char*)malloc(n * STRLEN); // kleinen Speicherblock anfordern
  char* strPtr2 = (char*)malloc(n * STRLEN); // kleinen Speicherblock anfordern
  printf("Bitte Text eingeben: \n");
  fgets(strPtr, STRLEN, stdin); // einlesen
  printf("\n");

  while (strPtr[strlen(strPtr) - 1] != '\n') // Ende erreicht, letztes Zeichen '\n'?
  {
    n++; // Anzahl Blöcke inkrementieren
    strPtr = (char*)realloc(strPtr, n * STRLEN); // größeren Speicher anfordern: n Blöcke
    fgets(strPtr + strlen(strPtr), STRLEN + 1, stdin); // weiter einlesen, terminierende 0 überschreiben, STRLEN + 1 Byte stehen zur Verfügung
  }

  printf("Nach welcher Zeichenfolge soll gesucht werden?\n");
  fgets(strPtr2, STRLEN, stdin); // einlesen
  printf("\n");

  while (strPtr2[strlen(strPtr2) - 1] != '\n') // Ende erreicht, letztes Zeichen '\n'?
  {
    n++; // Anzahl Blöcke inkrementieren
    strPtr2 = (char*)realloc(strPtr2, n * STRLEN); // größeren Speicher anfordern: n Blöcke
    fgets(strPtr2 + strlen(strPtr2), STRLEN + 1, stdin); // weiter einlesen, terminierende 0 überschreiben, STRLEN + 1 Byte stehen zur Verfügung
  }

  printf("Zeichenfolge wurde %i mal gefunden\n", Such(strPtr, strPtr2));
  return 0;
}

int Such(char* strPtr, char* strPtr2)
{
  int n = 0;
  int p = 0;
  int sip = 0;

  int ltext = strlen(strPtr) - 1;
  int lzfolge = strlen(strPtr2) - 1;
  int lgteilt = ltext / lzfolge;
  char* ptrarr[] = { NULL };

  while ((lgteilt) > 0)
  {
    for (int i = 0; i < lzfolge; i++)
    {
      if (strPtr[p] == strPtr2[i])
      {
        sip++;
      }

      p++;
    }

    lgteilt--;
  }

  return (sip / lzfolge);
}

Ich verstehe leider nicht ganz, wie man ein Pointer-Array anlegen soll, um die Fundstellen zu speichern.

Ich habe zwar eine Schleife, aber diese kann z. B. "yay" nicht mit "ay" vergleichen.

Danke für die Hilfe.

...zur Frage

In C ein unendliches Array?

das hier: char *array;

ist doch ein länge mit einer unendlichen länge, weil normalerweise macht man ja:

char array[10];

oder char array[ ] = "abcdefgehi";

wie kann ihc bei char *array die länge festlegen?

...zur Frage

Chudnovsky Algorithmus in C?

Ich versuche gerade den Chudnovsky Algorithmus in C zu implementieren um die nachkommastellen von Pi zu rechnen. Jedoch sind die häufigsten Ergebnisse immer nan, -nan, inf oder was wie 3.827783e-647. Ich hab auch verschiene print formate verwendet um das ergebnis auszugeben, aber da kam entweder 0.0000 oder inf raus.

Wie bekomm ich es hin das eine 'normale' Zahl rauskommt, quasi 3.14159...... usw.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

long double fact(long double n) {
  long double fac = 1.00;
  for (int i = 1; i<=n; i++) {
    if (i) {
      fac = fac * i;
    }
  }
  return fac;
}


int main(int argc, char* argv[]) {

  long double n, i;
  long double sum, pi, term;
  sum = 0.00;
  pi = 0.00;

  n = (atoi(argv[1]));

  for (i=0; i < n; i++) {
    term = (powl((-1.00), n) * fact(6.00*n) * (545140134.00*n + 13591409)) / (fact(3.00*n) * powl(fact(n), 3.00) * powl(640320.00, 3*n+3/2));

    sum += term;
  }
  sum = sum * 12;

  pi = 1 / sum;


  printf("PI: %Lf\n", pi);
  

  return 0;
}

...zur Frage

Größe von Datentypen in der Informatik?

Char ist ja 1 Byte groß, sprich 255 DEZ maximum. Ergibt sich ja aus der ASCII Tabelle.

Integer ist ja 4 Byte groß. Wenn ich jetzt long hinzufüge, werden dann einfach 4 Byte hinzugefügt und der Integer ist 8 Byte groß?

Und wie ist es bei minus Integern? das "-" ist doch ein char, oder? Also wenn der Integer nicht unsigend ist, dann kann ja ein "-" vorkommen. Ist dann dementsprechend der Integer wegen dem "-" char um 1 Byte größer und somit ein negatives long int 9 Byte groß, oder wie läuft es ab, wenn die Zahl negativ ist?

Ist der negative long int dann nur noch 7 Byte groß und der 1 Byte das Char? Dann kann man ja bei Minus Zahlen nicht mehr so große Zahlen abspeichern.

...zur Frage

Was möchtest Du wissen?

Deine Frage stellen