Angol

Főnév

floating-point number (tsz. floating-point numbers)

(informatika) lebegőpontos szám

Lebegőpontos számok C++ nyelven

A lebegőpontos számok a C++ programozási nyelvben azokat a számokat képviselik, amelyek tört részt is tartalmazhatnak. Ezeket a számokat általában olyan esetekben használjuk, amikor a pontosság fontos, például matematikai számításokban, mérnöki alkalmazásokban, fizikában vagy pénzügyi programokban.

1. Lebegőpontos adattípusok C++-ban

A C++ három alapvető lebegőpontos adattípust kínál:

float – Egyszeres pontosságú lebegőpontos szám
double – Kettős pontosságú lebegőpontos szám
long double – Nagyobb pontosságú lebegőpontos szám

float típus

Általában 32 biten tárolódik.
Körülbelül 6-7 számjegy pontosságot biztosít.
Példa:
```
float a = 3.14159f;
```
(A f utótag jelzi, hogy az érték float típusú.)

double típus

Általában 64 biten tárolódik.
Körülbelül 15-16 számjegy pontosságot biztosít.
Példa:
```
double b = 3.14159265358979;
```
(Alapértelmezés szerint a double típusú számok utótag nélkül is double típusúak.)

long double típus

A pontos mérete a rendszertől függően eltérhet (80, 96 vagy 128 bit).
Pontossága jellemzően 18-19 számjegy vagy több.
Példa:
```
long double c = 3.141592653589793238L;
```
(Az L utótag long double típust jelöl.)

2. Alapműveletek lebegőpontos számokkal

A lebegőpontos számokkal elvégezhetünk alapvető matematikai műveleteket:

#include <iostream>
using namespace std;

int main() {
    float a = 5.2f, b = 2.1f;
    
    cout << "Összeg: " << (a + b) << endl;
    cout << "Különbség: " << (a - b) << endl;
    cout << "Szorzás: " << (a * b) << endl;
    cout << "Osztás: " << (a / b) << endl;

    return 0;
}

Példa kimenet:

Összeg: 7.3
Különbség: 3.1
Szorzás: 10.92
Osztás: 2.47619

3. A lebegőpontos számok pontossági problémái

A lebegőpontos számok nem mindig tárolják pontosan az értékeket, mivel bináris formátumban tárolódnak. Példa erre:

#include <iostream>
using namespace std;

int main() {
    double x = 0.1 + 0.2;
    
    if (x == 0.3) {
        cout << "x pontosan 0.3!" << endl;
    } else {
        cout << "x nem pontosan 0.3, hanem: " << x << endl;
    }

    return 0;
}

Kimenet (valószínűleg):

x nem pontosan 0.3, hanem: 0.30000000000000004

Ez a bináris tárolás miatt történik, mivel 0.1 és 0.2 nem ábrázolható pontosan bináris formában.

Hogyan lehet összehasonlítani lebegőpontos számokat?

Mivel a lebegőpontos számok nem mindig pontosak, toleranciát (epsilon értéket) kell használni:

#include <iostream>
#include <cmath>  // abs függvényhez
using namespace std;

int main() {
    double x = 0.1 + 0.2;
    double epsilon = 1e-9; // Tűréshatár

    if (abs(x - 0.3) < epsilon) {
        cout << "x közel egyenlő 0.3-mal!" << endl;
    } else {
        cout << "x nem pontosan 0.3, hanem: " << x << endl;
    }

    return 0;
}

Kimenet:

x közel egyenlő 0.3-mal!

4. Speciális értékek és IEEE 754 szabvány

A C++ a lebegőpontos számokat az IEEE 754 szabvány szerint kezeli, amely speciális értékeket is definiál:

Pozitív és negatív végtelen (∞ és -∞)

double inf = 1.0 / 0.0;
double neg_inf = -1.0 / 0.0;

Nem szám (NaN - Not a Number)
```
double nanVal = 0.0 / 0.0;
```

Ezeket az értékeket a <cmath> könyvtár isinf() és isnan() függvényeivel ellenőrizhetjük:

#include <iostream>
#include <cmath>
using namespace std;

int main() {
    double val = 0.0 / 0.0;

    if (isnan(val)) {
        cout << "Ez egy NaN érték!" << endl;
    }

    return 0;
}

5. Lebegőpontos számok formázása kimeneten

A C++ lehetőséget biztosít a lebegőpontos számok formázott kiírására:

#include <iostream>
#include <iomanip> // std::setprecision
using namespace std;

int main() {
    double pi = 3.14159265358979;

    cout << "Alapértelmezett: " << pi << endl;
    cout << "3 tizedesjeggyel: " << fixed << setprecision(3) << pi << endl;
    cout << "Tudományos jelöléssel: " << scientific << pi << endl;

    return 0;
}

Kimenet:

Alapértelmezett: 3.14159
3 tizedesjeggyel: 3.142
Tudományos jelöléssel: 3.141593e+00

6. Véletlenszerű lebegőpontos számok generálása

A rand() függvény csak egész számokat generál, de átalakíthatjuk lebegőpontos számokká:

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

int main() {
    srand(time(0));
    float randomFloat = static_cast<float>(rand()) / RAND_MAX;
    
    cout << "Véletlenszám: " << randomFloat << endl;
    return 0;
}

Ez egy 0 és 1 közötti véletlenszerű lebegőpontos számot generál.

Összegzés

A float, double és long double adattípusokat használjuk lebegőpontos számokhoz.
Ezek binárisan tárolódnak, ezért lehetnek pontossági hibák.
Használjunk epsilon értéket az összehasonlításokhoz.
Az IEEE 754 szabvány speciális értékeket tartalmaz (NaN, inf).
A setprecision() segít a formázott kiírásban.
A véletlenszerű lebegőpontos számokat rand() segítségével generálhatjuk.

További információk

floating-point number - Szótár.net (en-hu)
floating-point number - Sztaki (en-hu)
floating-point number - Merriam–Webster
floating-point number - Cambridge
floating-point number - WordNet
floating-point number - Яндекс (en-ru)
floating-point number - Google (en-hu)
floating-point number - Wikidata
floating-point number - Wikipédia (angol)