Größe von Int

[Nerb]

Hallo,

Welche Größe (Anzahl der Bits) hat ein integer auf dem Meg8 (8bit) ?

mfg

[Superhirn]

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

[oberallgeier]

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.

[Nerb]

Hallo,
Danke für die Antworten. Ich war mir nur nicht ganz sicher, mit den 16 bit.
Aber jetzt weiß ich es wieder.
mfg

[oberallgeier]

Hi, Nerb,

... war mir nur nicht ganz sicher, mit den 16 bit...

Nur damit es keinerlei Mißverständnis gibt:
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.

[Nerb]

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

mfg

[johns]

fyi, es gibt in C den sizeof befehl, als einziger parameter wird der gewünschte type erwartet, also zb sizeof(int)

[Sternthaler]

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.

/*****************************************************************************

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

Gruß Sternthaler