Institute of Information Science - University of Miskolc

User Tools

Site Tools

Trace:
tanszek:oktatas:szamitastechnika:egyszeru_mintapeldak

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Next revision		Previous revision
tanszek:oktatas:szamitastechnika:egyszeru_mintapeldak [2022/09/05 21:09] – létrehozva kneheztanszek:oktatas:szamitastechnika:egyszeru_mintapeldak [2023/10/11 08:19] (current) – knehez
Line 1: Line 1:
 +==== A változók pontos megadása ====
 +
 +A következő érdekes példák a változók pontos típusmegadására figyelmeztetnek.
 +
 **Feladat**: Változók definíciója és alapvető számolások **Feladat**: Változók definíciója és alapvető számolások
-<code c>+<sxh c>
 #include <stdio.h> #include <stdio.h>
  
Line 18: Line 22:
     printf("f = %f \n", f);     printf("f = %f \n", f);
 } }
-</code>+</sxh>
  
 **Megjegyzés:** **Megjegyzés:**
-Jegyezzük meg, hogy a 10 általában minden programozási nyelvben egész számot jelent, binárisan 32 biten kódolva: 00000000 00000000 00000000 00001010 lesz. +Jegyezzük meg, hogy a 10 általában minden programozási nyelvben egész számot jelent, binárisan 32 biten kódolva: 
  
-A 10.0 jelenti a double típusú lebegőpontos számot ami 64 bites és így nézne ki: 0 10000000010 0100000000000000000000000000000000000000000000000000 és a 10.0f (igen, a végére egy f betűt írunk), jelenti a float típusú lebegőpontos számot ami ugyancsak 32 bites de így néz ki binárisan: 0 10000010 01000000000000000000000. A szóközök az előjel az exponens és a mantissza tagokat választják el egymástól. Látható tehát hogy a 10 10.0 10.0f három teljesen különböző módon van értelmezve kettes számrendszerben. +**00000000 00000000 00000000 00001010** lesz.  
 + 
 +A 10.0 jelenti a double típusú lebegőpontos számot ami 64 bites és így nézne ki:  
 + 
 +**0 10000000010 0100000000000000000000000000000000000000000000000000**  
 + 
 +és a 10.0f (igen, a végére egy f betűt írunk), jelenti a //float// típusú lebegőpontos számot ami ugyancsak 32 bites, de így néz ki binárisan:  
 + 
 +**0 10000010 01000000000000000000000**  
 + 
 +A szóközök az előjel az exponens és a mantissza tagokat választják el egymástól. Látható tehát hogy a 10 10.0 10.0f három teljesen különböző módon van értelmezve kettes számrendszerben. 
  
 **f = 70.0 / 3.0;** helyett ha ezt írjuk: **f = 70 / 3;** ezért fog más eredményt adni hiszen így elvesztjük a tizedesjegyeket. **f = 70.0 / 3.0;** helyett ha ezt írjuk: **f = 70 / 3;** ezért fog más eredményt adni hiszen így elvesztjük a tizedesjegyeket.
  
-**Feladat**: Hibásan számol a c nyelv??? Mi lehet a hiba?+**1. Feladat**: Hibásan számol a c nyelv??? Mi lehet a hiba?
  
-<code c>+<sxh c>
 #include <stdio.h> #include <stdio.h>
  
Line 40: Line 54:
     printf("c = %d \n", c);     printf("c = %d \n", c);
 } }
-</code>+</sxh> 
 +A 3 nem osztója a 13-nak. A 13 / 3 eredményét a c változóban egészként tároljuk, ilyenkor az eredmény egész részét aza a 4-et fogjuk eredményként kapni.
  
-**Feladat**: Az előző kódban változtassuk meg a c-t float-ra és a printf()-ben használjunk %f-et és próbáljuk ki úgy is. Segített?+Ahhoz hogy a tizedes jegyeket is megkapjuk, próbáljunk meg áttérni float adattípusra, a következő példa alapján.
  
-<code c>+**2. Feladat**: Az előző kódban változtassuk meg a c-t float-ra és a printf()-ben használjunk %f-et és próbáljuk ki úgy is. Segített? 
 + 
 +<sxh c>
 #include <stdio.h> #include <stdio.h>
  
Line 55: Line 72:
     printf("c = %f \n", c);     printf("c = %f \n", c);
 } }
-</code>+</sxh>
  
-**Feladat**: Hozzon létre egy **unsigned int** változót 2 illetve egy **int** változót -1 értékkel és végezzen összehasonlítást, hogy 2 > -1? Magyarázza meg, hogy mi történik és miért?+Azért nem segít, mert az a / b elvégzésekor, mivel mind a két érték egész, az eredmény megint 4 lesz. A c-t hiába adtuk meg float-ként, akkor is a 4-es kerül bele.
  
-<code c>+**3. Feladat**: Hozzon létre egy **unsigned int** változót 2 illetve egy **int** változót -1 értékkel és végezzen összehasonlítást, hogy 2 > -1? Magyarázza meg, hogy mi történik és miért? 
 + 
 +<sxh c>
 #include <stdio.h> #include <stdio.h>
  
Line 68: Line 87:
     if ( b > a)     if ( b > a)
     {     {
-       printf("b nagyobb, mint a");+       printf("a 2 nagyobb, mint a -1"); 
 +    } 
 +    else 
 +    { 
 +       printf("a 2 kisebb, mint a -1 ???");
     }     }
-    printf("vege"); 
 } }
-</code>+</sxh>
  
-**Miért számol hibásan (pontatlanul) a következő kód?** +**4. Feladat: Miért számol hibásan (pontatlanul) a következő kód?** 
-<code c>+<sxh c>
 #include <stdio.h>  #include <stdio.h> 
  
Line 85: Line 107:
     printf("%f\n", a / b);     printf("%f\n", a / b);
 } }
-</code>+</sxh>
  
 Nézzük meg hogyan ábrázoljuk a változókat: https://www.h-schmidt.net/FloatConverter/IEEE754.html  Nézzük meg hogyan ábrázoljuk a változókat: https://www.h-schmidt.net/FloatConverter/IEEE754.html 
Line 95: Line 117:
 Magyarázzuk meg miért nem működik a (double) (a/b) típuskonverzió? Magyarázzuk meg miért nem működik a (double) (a/b) típuskonverzió?
  
-**Miért számol hibásan (pontatlanul) a következő kód?** +**5. Feladat: Miért számol hibásan (pontatlanul) a következő kód?** 
-<code c>+<sxh c>
 #include <stdio.h> #include <stdio.h>
 #define N 3 + 5 #define N 3 + 5
Line 105: Line 127:
     printf("%d\n", a * N);     printf("%d\n", a * N);
 } }
-</code>+</sxh>
  
-Az eredménynek 2 * 8 nak kellene lennie, de 11-et ír ki, mi lehet a hiba? Az a probléma, hogy a #define nem végez műveletet, hanem egyszerűen behlyettesít, így az a * N művelet a * 3 + 5 lesz, ami a precedencia (sorrendi) szabályok miatt 6 + 5 = 11 lesz.+Az eredménynek 2 * 8 nak kellene lennie, de 11-et ír ki, mi lehet a hiba? Az a probléma, hogy a #define nem végez műveletet, hanem egyszerűen behelyettesít, így az a * N művelet a * 3 + 5 lesz, ami a //precedencia// (sorrendi) szabályok miatt 6 + 5 = 11 lesz.
  
 ==== Formátum leírók ==== ==== Formátum leírók ====
tanszek/oktatas/szamitastechnika/egyszeru_mintapeldak.1662412166.txt.gz · Last modified: 2022/09/05 21:09 by knehez