Hallo,
Welche Größe (Anzahl der Bits) hat ein integer auf dem Meg8 (8bit) ?
mfg
Druckbare Version
Hallo,
Welche Größe (Anzahl der Bits) hat ein integer auf dem Meg8 (8bit) ?
mfg
int: 16bit, ungefähr von -32000 bis +32000
unsigned int: 16bit von 0 bis ca +64000
long: 32bit
es gibt aber auch was praktischeres:
int8_t - bedeutet char
uint8_t - bedeutet unsigned char
int16_t - int
uint16_t - unsigned int
https://www.roboternetz.de/wissen/in...anze_Zahlen.29
mit anderen Worten:
2hoch8 = 8 bit (Wert siehe im Link oben)
2hoch16 = 16 bit (dito)
2hoch32 = ...
2hoch64 = ...
Wenn ein Vorzeichen dazukommt, dann wird (ungefähr) die Hälfte für den negativen Anteil genommen. Ungefähr deswegen, weil es Vereinbarungen gibt, um eine eindeutige "Null" zu bekommen.
Ausserdem gilt noch: 8 Bit ist ein Byte. Also ein 32-bit-integer hat 4 Byte.
Hallo,
Danke für die Antworten. Ich war mir nur nicht ganz sicher, mit den 16 bit.
Aber jetzt weiß ich es wieder. :cheesy:
mfg
Hi, Nerb,
Nur damit es keinerlei Mißverständnis gibt:Zitat:
Zitat von Nerb
Der mega8 ist ein "• High-performance, Low-power AVR® 8-bit Microcontroller" - so stehts im Datenblatt. Was heißt das?
Der mega8 hat Register mit 8 bit Datenbreite, also mit 1 Byte. Er kann (von vernachlässigbaren Ausnahmen abgesehen) mit einem einzigen Maschinenbefehl nur Daten mit einer Größe von 1 Byte = 8 bit zur gleichen Zeit verarbeiten. Beispielsweise kann er mit einem einzigen Befehl zwei 8-Bit-Integer addieren. Was macht man aber bei 16-bit-Integer oder gar 4-Byte(=32bit)-Integer)? Durch geschickte Programmierung gehts. Beim Addieren einer 16 bit-Integer werden zuerst die zwei niederwertigen Bytes addiert und mit dem Überlauf (Carrybit) danach die beiden höherwertigen Bytes addiert. Damit erhalte ich eine 16-Bit-Addition. Die anderen Rechnungen gehen - sagen wir mal - sinngemäß. Für solche Rechnungen benötigst Du dann deutlich mehr Rechenschritte.
Fazit: Du kannst mit einer geeigneten Programmiersprache auch Integerwerte mit 16 Bit, 32 Bit und höher für Deine Rechnungen benutzen. In Assembler geht das ja auch, aber da musst Du wie im obigen Beispiel den genauen Ablauf der Rechnung eben selber programmieren. Bei einer "Hochsprache" wie z.B. C erledigt der Compiler solche Aufgaben für Dich - sprich, der hat bereits fertige Routinen für Rechnungen mit größeren Integerwerten verfügbar, die dann beim compilieren zu Deinem Code dazugebunden werden.
Fazit: Der mega8 ist ein 8-bit-Controller. Er kann auch Integerwerte mit zwei, vier oder mehr Bytes verarbeiten.
Hallo,
danke für deine ausführliche Erklärung. Da ich C verwende muss ich mir um interne Rechenoperationen keinen Kopf machen.
Da int auf einem 32 bit system 32 bit hat, auf einem 64 bit system 64 bit, dachte ich ganz analog weiter und kam auf 8bit, was aber schon durch char gegeben ist. Das es nun letztendlich 16 bit sind, beruhigt mich das wieder :cheesy:
mfg
fyi, es gibt in C den sizeof befehl, als einziger parameter wird der gewünschte type erwartet, also zb sizeof(int)
Hallo Nerb,
ich bin mir nicht zu 100% sicher, aber ein int-Wert ist meines Wissens nach der einzige Datentyp, der auf jedem System immer genau 16 Bit hat.
Bei char weiss ich definitiv, dass da auch schon mal 16 Bit Speicherplatz verbrauchen werden, aber trotzdem nur 8 nutzbare Bits zur Datenhaltung im Programm vorhanden sind. (Natürlich nicht auf dem Asuro. Das hatte ich mal auf einer dicken IBM-Kiste gefunden).
Den Hinweis von johns zum sizeof() hatte ich vor längerer Zeit schon mal auch für den Asuro umgesetzt.
Die Datentypen werden nach Tastendruck an eine Terminalemulation zum PC gesendet. Ist nichts wildes, aber eventuell mal interressant.
Gruß SternthalerCode:/*****************************************************************************
Dateiname: test.c
Projekt: Ausgabe der Bytelaengen aller Variablentypen.
Funktionen
----------
main()
Hauptschleife. Bedienung/Auswahl der Funktionen
Taste N: Nach dem Loslassen irgendeiner gedrueckten Taste wird die
benutzte Byteanzahl aller Datentypen ueber IR ausgegeben.
Version Datum Autor / Kommentar
------- ---------- ------------------------------------------------------
V001 14.06.2006 Sternthaler
Startversion
Copyright (c) 2006 Sternthaler
*****************************************************************************/
#include <stdio.h>
#include <string.h>
#include "asuro.h"
/*
Lokale Funktionsdeklarationen
*/
/*
Sourceglobale Variablen
*/
/*
Lokale defines
*/
/*****************************************************************************
*/
int main (void)
{
char v_char;
unsigned char v_u_char;
short v_short;
unsigned short v_u_short;
int v_int;
unsigned int v_u_int;
long v_long;
unsigned long v_u_long;
float v_float;
double v_double;
int8_t v_int8;
uint8_t v_uint8;
int16_t v_int16;
uint16_t v_uint16;
int32_t v_int32;
uint32_t v_uint32;
int64_t v_int64;
uint64_t v_uint64;
unsigned char sw;
char text [100];
Init ();
while (1)
{
sw = PollSwitch ();
while (PollSwitch ())
;
if (sw)
{
strcpy (text, "Speichergroessen der verschiedenen Datentypen in Byte\n\r");
SerWrite ((unsigned char *)text, strlen (text));
strcpy (text, "\n\r--> Integer (Ganzzahl)\n\r");
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, " char : %d\n\r", sizeof (v_char));
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, "unsigned char : %d\n\r", sizeof (v_u_char));
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, " int : %d\n\r", sizeof (v_int));
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, "unsigned int : %d\n\r", sizeof (v_u_int));
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, " short : %d\n\r", sizeof (v_short));
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, "unsigned short : %d\n\r", sizeof (v_u_short));
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, " long : %d\n\r", sizeof (v_long));
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, "unsigned long : %d\n\r", sizeof (v_u_long));
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, " int8_t : %d\n\r", sizeof (v_int8));
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, " uint8_t : %d\n\r", sizeof (v_uint8));
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, " int16_t : %d\n\r", sizeof (v_int16));
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, " uint16_t : %d\n\r", sizeof (v_uint16));
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, " int32_t : %d\n\r", sizeof (v_int32));
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, " uint32_t : %d\n\r", sizeof (v_uint32));
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, " int64_t : %d (nur ohne compiler option -mint8)\n\r", sizeof (v_int64));
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, " uint64_t : %d (nur ohne compiler option -mint8)\n\r", sizeof (v_uint64));
SerWrite ((unsigned char *)text, strlen (text));
strcpy (text, "\n\r--> Floating (Flieskomma)\n\r");
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, " float : %d\n\r", sizeof (v_float));
SerWrite ((unsigned char *)text, strlen (text));
sprintf (text, " double : %d\n\r", sizeof (v_double));
SerWrite ((unsigned char *)text, strlen (text));
}
}
return 0;
}