-
        

Ergebnis 1 bis 8 von 8

Thema: Größe von Int

  1. #1
    Benutzer Stammmitglied
    Registriert seit
    04.01.2008
    Beiträge
    41

    Größe von Int

    Anzeige

    Hallo,

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

    mfg

  2. #2
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    19.03.2005
    Ort
    Villach
    Alter
    26
    Beiträge
    995
    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

  3. #3
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    7.551
    http://www.roboternetz.de/wissen/ind...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.
    Ciao sagt der JoeamBerg

  4. #4
    Benutzer Stammmitglied
    Registriert seit
    04.01.2008
    Beiträge
    41
    Hallo,
    Danke für die Antworten. Ich war mir nur nicht ganz sicher, mit den 16 bit.
    Aber jetzt weiß ich es wieder.
    mfg

  5. #5
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    7.551
    Hi, Nerb,

    Zitat Zitat von 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.
    Ciao sagt der JoeamBerg

  6. #6
    Benutzer Stammmitglied
    Registriert seit
    04.01.2008
    Beiträge
    41
    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

  7. #7
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    11.08.2005
    Beiträge
    178
    fyi, es gibt in C den sizeof befehl, als einziger parameter wird der gewünschte type erwartet, also zb sizeof(int)
    "A robot with guns for arms shooting a plane made out of guns that fires guns" - Nelson Muntz

  8. #8
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    29.05.2005
    Beiträge
    1.018
    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.
    Code:
    /*****************************************************************************
    
       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
    Lieber Asuro programieren als arbeiten gehen.

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •