Problem z cin.good/cin.fail a float.

Kiedy wpisałem program podany w rozdziale 9 czyli:

Wszystko mi wyświetla poprawnie czyli wynikiem tego jest:

Czyli poprawnie wykrywa, że została wpisana niepoprawna dana.
Napisałem później taki o to program i nie działa mi ta funkcja poprawnie gdyż nawet po wpisaniu liter stwierdza, że zostały podane poprawne dane :/ Ma ktoś wytłumaczenie co jest nie tak? Używam Microsoft Visual Studio 2012 Professional

Np. Dla danych wejściowych:


Wyświetla

"CzySukces" to przecież nie jest wywołanie funkcji cin.good()...

Zmienne CzySukces1,2,3 miały nadaną wartośc zanim jakiekolwiek dane zostały wczytane, stan tych zmiennych nie zmieni się magicznie sam.

#include "iostream" to jest źle, powinno być <iostream>

Używanie cin.sync() nie ma sensu.

Używam cin.sync(); bo tak pisze w tym kursie na tej stronie.
Dlaczego nie używa się tego? Przecież z tego co zrozumiałem to czyści to ten bufor z danymi co wpisaliśmy, bo jeśli ktoś złośliwie wpisze np. 123nie, 452 to gdy wczytam to do zmiennej float to odczyta chyba tylko do przecinka a do float samą cyfrę 123 wczyta. A , 452 dalej został i byłby wczytany do następnej zmiennej i byłby problem? Źle to rozumiem?

To co robi cin.sync() zależy od konkretnej implementacji i jest nieprzenośne, standard nie daje żdanych gwarancji, że sync() wyczyści bufor.
Lepiej używaj
http://en.cppreference.com/w/cpp/io/basic_istream/ignore
a jeszcze lepiej zamiast  wczytujesz całą linię tekstu  i ją analizujesz.
http://en.cppreference.com/w/cpp/string/basic_string/getline

Witaj, Unknown22. Twoje pytanie dotyczy problemu z niepoprawnym sprawdzaniem stanu strumienia wejścia w C++. Analizując Twój kod, mogę wskazać kilka kluczowych błędów i wskazać, jak je naprawić.

---

### 1. Błąd w ustawianiu zmiennych CzySukces1, CzySukces2, CzySukces3
W Twoim kodzie zmienna `CzySukces1` (i pozostałe) jest inicjalizowana **przed** jakimkolwiek wprowadzeniem danych:
```cpp
bool CzySukces1 = cin.good();
```
Tutaj `cin.good()` zwraca stan strumienia **w momencie inicjalizacji zmiennej**, czyli na samym początku programu. Natomiast wprowadzanie danych (`cin >> a;`) może spowodować zmianę stanu strumienia (np. błąd wczytania). Jeśli jednak **nie przypiszesz ponownie** wyniku `cin.good()` do `CzySukces1`, zmienna ta pozostanie z wartością z inicjalizacji (czyli `true`), mimo że wczytanie danych mogło się nie powieść.

**Poprawna wersja:**
```cpp
cout << "Podaj pierwsza liczbe: ";
cin >> a;
CzySukces1 = cin.good();  // <---- tutaj! sprawdzenie *po* wczytaniu
```

---

### 2. Niepoprawne użycie `cin.sync()`
Funkcja `cin.sync()` jest **nieprzenośna** i **niezalecana** w standardowym kodzie C++. Jej działanie zależy od implementacji biblioteki C++ i może różnić się między kompilatorami. W Twoim przypadku, po wprowadzeniu danych (np. `123nie`), strumień wychodzi w stan błędu, ale bufor wejściowy pozostaje z nieprzetworzoną częścią danych (np. `nie`). Użycie `cin.sync()` nie gwarantuje, że bufor zostanie wyczyszczony.

**Zamiast `cin.sync()`, zalecam:**
```cpp
cin.clear();                  // reset stanu błędnego
cin.ignore(numeric_limits<streamsize>::max(), '\n');  // wyczyszczenie bufora do znaku nowej linii
```
Wymaga to dołączenia nagłówka `<limits>` i użycia `std::numeric_limits`.

---

### 3. Niepoprawne przetwarzanie niepoprawnych danych
Po wprowadzeniu danych typu `tak 123` lub `33.22nie`, strumień `cin` przechodzi w stan błędu (`failbit`). Pomimo użycia `cin.clear()`, **nieprawidłowe dane pozostają w buforze** i są próbowane ponownie przy kolejnym `cin >> c;`. To powoduje, że program "próbuje" wczytać niepoprawne dane ponownie, co prowadzi do niespodziewanych wyników.

---

### 4. Poprawny sposób sprawdzania wczytania danych
Zamiast zapisywać wynik `cin.good()` do zmiennej na starcie, sprawdzaj go **po każdym wczytaniu**. Przykład poprawnej implementacji:
```cpp
#include <iostream>
#include <limits>
using namespace std;

int main() {
    float a, b, c;
    bool CzySukces1, CzySukces2, CzySukces3;

    cout << "Podaj pierwsza liczbe: ";
    cin >> a;
    CzySukces1 = cin.good();

    if (!CzySukces1) {
        cin.clear();
        cin.ignore(numeric_limits<streamsize>::max(), '\n');
    }

    cout << "Podaj druga liczbe: ";
    cin >> b;
    CzySukces2 = cin.good();

    if (!CzySukces2) {
        cin.clear();
        cin.ignore(numeric_limits<streamsize>::max(), '\n');
    }

    cout << "Podaj trzecia liczbe: ";
    cin >> c;
    CzySukces3 = cin.good();

    cout << "Pierwsza: " << a << " (" << (CzySukces1 ? "OK" : "Błąd") << ")\n";
    cout << "Druga: " << b << " (" << (CzySukces2 ? "OK" : "Błąd") << ")\n";
    cout << "Trzecia: " << c << " (" << (CzySukces3 ? "OK" : "Błąd") << ")\n";

    return 0;
}
```

---

### 5. Dodatkowe porady
- **Unikaj `using namespace std;`** w większych projektach — prowadzi to do konfliktów nazw.
- Zawsze **sprawdzaj poprawność wczytania danych** po każdym `cin >> ...`.
- Używaj `cin.ignore(...)` po `cin.clear()` w przypadku błędnego wprowadzenia danych.
- Jeśli chcesz obsłużyć bardziej skomplikowane dane (np. tekst z liczbą), rozważ użycie `std::getline` i konwersji (np. `std::istringstream`).

---

Dzięki tym zmianom Twój program będzie poprawnie reagował na błędy wprowadzania danych i wypisywał właściwe informacje o sukcesie czy niepowodzeniu wczytania. Jeśli masz więcej pytań — chętnie pomogę!