Wszystkie wpisy, których autorem jest ibs_sel_nanonco

Jak ukryć swój numer telefonu na telefonie z Androidem.

Jak ukryć swój numer telefonu jak do kogoś dzwonimy (Android)?

Czasami chcemy żeby dzwoniąc do kogoś nasz numer był ukryty, tzn. żeby naszemu rozmówcy nie wyświetlał się nasz numer, tylko informacja o numerze prywatnym. Ala jak to zrobić na telefonie z systemem Android? Poniżej opis jak to zrobić krok po kroku.

1. Wchodzimy do ustawień (settings). W przeważającej większości przypadków jest to ikonka koła zębatego po wyświetleniu menu kiedy przeciągamy palcem od góry ekranu w dół.
2. Następnie szukamy opcji "Ustawienia połączeń". W zależności od marki telefonu i wersji Androida możemy tam trafić na różne sposoby. W niektórych modelach będzie to ścieżka "Ustawienia" -> "Aplikacje systemowe" -> "Telefon" -> "Ustawienia połączeń" a w innych modelach będzie to ścieżka "Ustawienia" -> sekcja "Urzędzenie" -> "Ustawienia połączeń".
3. Jeżeli już jesteśmy w opcjach "Ustawienia połączeń" to z reguly ukrywanie ID rozmówcy będzie umiejscowione albo w "Ustawieniach dodatkowych" albo będzie się to nazywało "Ustawienia zaawansowane".
4. Teraz szukamy opcji "Identyfikacja rozmówcy" lub "ID rozmówcy".
5. Po wybraniu tej opcji zobaczymy trzy opcje: "Domyślna wartość dla sieci" , "Ukryj numer" lub "Pokaż numer" i w zależności od potrzeby chwili ustawiamy się na konkretnej opcji. Skoro chcemy ukryć numer wybieramy opcję "Ukryj numer".

Ukrywanie numeru to miecz obosieczny. Musimy pamiętaj o tym, że ktoś do kogo chcemy się dodzwonić może mieć ustawione połączenia w ten sposób, że nie chce przyjmować rozmów przychodzących od numerów prywatnych/ukrytych bo bardzo często z takich numerów dzwonia gnębiący nas akwizytorzy. W takim przypadku nasze połączenie będzie automatycznie odrzucone.

 

Jak obliczyć średnie zużycie paliwa w samochodzie?

Często zastanawiacie się jak obliczyć "ile pali" mój samochód? Sprawdzenie tego nie jest zbyt trudne. W tym artykule krok po kroku opiszę całą procedurę dojścia do odpowiedzi na to pytanie.

Od czego zacząć? Na początku musimy zrobić dwie rzeczy. Pierwsza to zatankować nasz pojazd do pełna. Druga to wyzerować licznik który wskazuje aktualnie przejechane kilometry w podróży lub spisać ilość kilometrów na liczniku "głównym", który wskazuje przebieg auta od wypuszczenia pojazdu na rynek. W zależności w jakim trybie spalania chcemy mierzyć np. w trybie miejskim lub na autostradzie, powyższe czynności musimy wykonać przed jazdą samochodem w danym trybie np. Jeżeli chcemy dowiedzieć się ile spala nasze autko w trybie miejskim to wiedząc, że w tygodniu będziemy poruszali sie tylko po mieście tankujemy w np. w niedzielę wieczorkiem, resetujemy licznik (lub spisujemy "główny") i jeździmy sobie cały tydzień po mieście. Jeżeli chcemy jednak sprawdzić ile nasze auto spala na autostradzie to robimy to przed jakąś podróżą właśnie na tego typu drodze. To jak długi okres czasu będziemy testować zależy wyłącznie od Ciebie. Wiadomo, że im więcej danych, w tym przypadku im dłużej będziemy jeździć w danym trybie, tym lepiej.
OK. Skończyły się nasze pomiary, skończył się tydzień jazdy po mieście (lub dojechaliśmy do celu naszej podróży poruszając się autostradą) więc przyszedł czas na wyliczenie średniego spalania naszego auta. W tym momencie wykonujemy także dwie czynności. Tankujemy auto ponownie do pełna i  sprawdzamy ile wskazał nasz licznik podróży (lub jaka jest różnica na liczniku "głównym" jeśli wybraliśmy tą opcję).
Mamy wtedy dwie informacje:
1. Ilość zużytego paliwa przez nasze auto.
2. Ilość przejechanych kilometrów.

Teraz wystarczy nasze dane podstawić do wzoru:

(ilość_zużytego_paliwa / ilość_przejechanych_kilometrów) * 100 = średnie_spalanie_na_100km

Do obliczeń przyjmijmy jakieś przykładowe dane np.:
1. Podczas naszej podróży nasze auto spaliło 22 litry paliwa
2. Podczas naszej podróży przejechaliśmy 300 km.

podstawmy dane do wzoru

 (22 l / 300 km) * 100 = 7,33 l

W wyniku naszych obliczeń otrzymaliśmy wartość 7,33. To jest właśnie wartość średniego spalania naszego auta na 100 km. Innymi słowy nasze auto na każde 100 km (podczas naczego testu) spaliło 7,33 l paliwa.

Jak obliczyć cenę zużycia prądu przez konkretne urządzenie?

Pewnie nie raz zastanawialiście się ile kosztuje zagrzanie wody w czajniku elektrycznym, albo ile kosztuje dziennie działanie komputera lub ile kosztuje miesięczne lub roczne użytkowanie danego urządzenia? W pewnym momencie też stanąłem przed takim pytaniem i postanowiłem sam oblicz ile energii zużywają moje urządzenia w domu.

Do obliczenia kosztów użytkowania urządzeń musisz znać ilość energii którą pobiera urządzenie, która wyrażona jest w Watach (W) i czas użytkowania urządzenia. Z reguly taką informację znajdziesz na opakowaniu lub na naklejce z tyłu lub pod spodem urządzenia.

Przykład:
Dla lepszego zobrazowania obliczeń weźmy pod uwagę czajnik elektryczny o mocy 1300 W i przyjmijmy, że zagotowanie pełnego czajnika wody zajmie nam 5 minut.

Moc czajnika wyrażona jest w Watach (W) a czas zagotowania wody w minutach. Koszty energii wyrażone są w złotych (zł) za 1 kWh (kilowatogodzinę).

Co wiemy:
moc urządzenia (czajnika) = 1300 W
czas działania urządzenia = 5 minut
cena energii za 1 kWh = 0,55 zł (uśredniona cena energii w Polsce za 1 kWh w 2018 roku na podstawie danych od dostawców prądu)

Zwróć uwagę że cena energii jest wyrażona w kWh (kilowatogodzinach), moc urządzenia w Watach (W) a czas działania urządzenia w minutach. Trzeba to wszystko tak poprzeliczać żeby do siebie pasowało.

Żeby otrzymać ilość zużytych przez urządzenie kWh musimy moc urządzenia, wyrażoną w Watach (W), zamienić na kW (kilowaty) a czas w minutach zamienić na godziny i podstawić do wzoru.

moc_urzązenia * czas_działania_urządzenia = ilość_zużytych_kWh

a więc:
żeby zamienić moc urządzenia na kW musimy moc w Watach pomnożyć przez 1000. To tak jak z dystansem, 1 km to 1000 m. Tak samo z mocą 1 kW to 1000 W. Ok to już mamy.
Teraz zamieńmy czas działania urządzenia, wyrażoną w minutach, na godziny. Żeby wiedzieć ile to jest 5 minut wyrażone w godzinach musimy podzielić 5 (czas działania urządzenia) przez 60 (bo godzina ma 60 minut). Zaokrąglony wynik to 0,083 h (godzina).

możemy już podstawić nasze dane do powyższego wzoru:

moc_urzązenia * czas_działania_urządzenia = ilość_zużytych_kWh

1,3 kW * 0,083 h = 0,1079 kWh

Wynikiem powyższego równania jest zużycie energii przez czajnik w ciągu 5 minut jego działania. Wynik jest wyrażony w kWh (kilowatogodziny). Teraz żeby poznać ostateczną cenę wystarczy przemnożyć nasz wynik przez koszt 1 kWh czyli w naszym przypadku przez 0,55 zł.

0,1079 kWh * 0,55 zł = 0,05945 zł = ok. 6 groszy

Rozwiązanie naszego problemu:
Podgrzanie wody w czajniku o mocy 1300 W, przy założeniu że potrwa to 5 minut, będzie nasz kosztowało w przybliżeniu 6 groszy.

 

 

C++ kurs podstawy programowania. Pętla DO WHILE.

Pętla do … while to nic innego jak inny wariant pętli while. Różnica jest tylko taka, że pętla do … while sprawdza warunek na końcu pętli przez co musi się wykonać choćby raz mimo, że warunek nie będzie spełniony. Przykład wyświetlenia liczb od 1 do 10 za pomocą pętli do … while poniżej.

    do
    {
        cout << i << endl;
        i++;
    }
    while(i<=10);

Widzisz, że składnia się trochę różni. Na początku jest słówko do, później, pomiędzy nawiasami klamrowymi, mamy ciało pętli a dopiero na końcu słówko while i warunek. Wszystko kończymy znakiem średnika. Efekt uruchomienia powyższej pętli poniżej.
cpp c++ kurs programowania pętla do while

 


c++ kurs programowania obiektowego spis treści 

 

 

C++ kurs podstawy programowania. Pętla WHILE.

Pętla  WHILE
Drugą pętlą którą poznamy jest pętla while. Na początek zaznajomimy się ze składnią tej pętli.

    while(warunek)
    {
        // cialo petli while
        // instrukcja lub blok instrukcji
        // do wykonania gdy warunek spelniony
    }

W pętli while instrukcja (lub blok instrukcji) będzie się wykonywała tyle razy aż warunek nie będzie spełniony.  Należy pamiętać, żeby w ciele pętli należy zaprogramować taki mechanizm, żeby w jakiejś konkretnej sytuacji była możliwość zakończenia pętli w przeciwnym wypadku zapętlimy ją w nieskończoność.
Spróbujmy teraz zapisać z użyciem pętli while przykład, który oprogramowywaliśmy dla pętli for, czyli klasyczne wyświetlenie na ekranie liczb od 1 do 10.

    int i=1;
    while(i<=10)
    {
        cout << i << endl;
        i++;
    }

Na początku deklarujemy sobie zmienną i która w tym przypadku będzie potrzebna do sprawdzania warunku wyjścia z pętli. Następnie po słówku while definiujemy warunek który będzie sprawdzany przed uruchomieniem każdego obiegu pętli, czy jest spełniony. Jeżeli będzie spełniony (wartość TRUE) pętla się wykona, w przeciwnym wypadku (wartość FALSE) pętla w ogóle przestaje się wykonywać. Widzisz, że za każdym razem w pętli while wyświetlamy na ekranie wartość zmiennej i. Za każdym jednak razem jej wartość jest zwiększana o 1 poleceniem i++ . W momencie kiedy zmienna i osiągnie wartość 11 czyli warunek nie będzie już spełniony pętla przestaje się wykonywać. Jeżeli od początku warunek nie będzie spełniony pętla while nie wykona się ani razu. Efekt uruchomienia naszego kodu poniżej.
cpp c++ kurs programowania pętla while

 


c++ kurs programowania obiektowego spis treści 

 

 

C++ kurs podstawy programowania. Pętla FOR.

Pętla FOR
Jak już wspomniałem wcześniej pętle są wykorzystywane do cyklicznego wykonywania zadanego kodu. Jeżeli z góry wiemy ile razy chcemy wykonać dany zestaw instrukcji to pętla for jest idealna do tego zadania. Pętle tego typu nazywamy licznikowymi bądź iteracyjnymi, bo z reguły startujemy od jakiejś wartości początkowej, przy każdym obrocie (obiegu) pętli wartość licznika zwiększamy o jeden, do momentu kiedy pętla osiągnie górną granicę. Ale najlepiej objaśnię to na konkretnym przykładzie. Będzie to znowu klasyka gatunku, czyli wyświetlenie na ekranie liczb od 1 do 10.

    int i = 1;
    for( i; i <= 10 ; i++)
        cout << i << endl;

Przeanalizujmy teraz nasz kod. Na początku zadeklarowałem zmienną i = 1 o typie int. Będzie ona spełniała funkcję licznika dla pętli for. No i teraz sedno sprawy, czyli sama pętla. W Nawiasie po słówku for podajemy trzy argumenty. Pierwszy to warunek początkowy, czyli w naszym przypadku i. Tak jak pisałem wcześniej nasza zmienna i będzie spełniała funkcję licznika, czyli na początku licznik ustawiamy na 1. Drugi parametr to tzw. górna granica, czyli warunek dla którego pętla przestanie się wykonywać. W naszym przypadku pętla ma przestać się wykonywać kiedy wartość licznika i będzie mniejsza lub równa 10 i to mamy właśnie zapisane w drugim argumencie i <=10 . Jeżeli warunek będzie spełniony pętla się wykona, jeżeli nie to pętla stanie. W trzecim argumencie musimy powiedzieć kompilatorowi jak będzie zmieniał się nasz licznik. W naszym przypadku chcemy, żeby licznik zwiększał się o 1 przy każdym obiegu pętli, dlatego zastosowałem inkrementację zmiennej i w postaci składni i++ . To co znajduje się w następnej linii to instrukcja którą chcemy wykonać przy każdym obiegu pętli. Jeżeli tych instrukcji wyłoby więcej to umieszczamy je w nawiasach {}. My chcemy, przy każdym obiegu pętli, wyświetlić wartość licznika i. Możemy uzyskać ten efekt korzystając ze składni cout << i << endl; . Oczywiście endl na końcu oznacza, przy każdym obiegu pętli, przejście do następnej linii tak, żeby każda wartość wyświetliła się w osobnej linii. Wrzućmy nasz kod w startowy program i uruchomimy go.

#include <iostream>

using namespace std;

int main()
{
    int i = 1;
    for( i; i <= 10 ; i++)
        cout << i << endl;

    return 0;
}

Po uruchomieniu na ekranie zobaczymy.
 cpp c++ course kurs programowania pętla for loop for
Właśnie o taki efekt nam chodziło, więc program zaliczamy do działających prawidłowo. Zwróć uwagę, że pętla for sprawdza warunek przed wykonaniem kodu w pętli. Jeżeli wiec nie będzie on spełniony kod się nie wykona. Jeżeli od początku warunek nie będzie spełniony pętla for nie wykona się ani razu.

 


c++ kurs programowania obiektowego spis treści 

 

 

C++ kurs podstawy programowania. Instrukcja warunkowa switch case.

Instrukcja SWITCH…CASE
Innym pomysłem na rozwiązanie problemu obsługi warunków jest instrukcja switch…case (czasami nazywana instrukcją wielokrotnego wyboru). Poniżej definicja i zaraz zabieram się do objaśniania kodu.

switch(zmienna)
{
case wartosc_1:
    // jeżeli zmienna = wartość_1 to wykonaj kod który znajduje się tutaj
    break;
   
case wartosc_2:
    // jeżeli zmienna = wartość_2 to wykonaj kod który znajduje się tutaj
    break;
   
    //...
case wartosc_n:
    // jeżeli zmienna = wartość_n to wykonaj kod który znajduje się tutaj
    break;
   
default:
// kod który wykona się w momencie kiedy wartość zmiennej zmienna
   //     nie będzie oprogramowana w żadnym z powyższych przypadków
    break;
}

Na początku widzisz słówko switch i parametr w nawiasie. Tym parametrem jest wartość zmiennej i w zależności od tej wartości switch zachowa się tak jak to mu oprogramujemy. Po słówku case oprogramowujemy konkretne przypadki, co komputer ma zrobić w zależności od wartości zmiennej zdefiniowanej w parametrze instrukcji switch. Słówko break przerywa działanie instrukcji switch. Wykonamy teraz małe ćwiczenie napiszemy program który zapyta użytkownika o liczbę z przedziału od 1 do 5. Pobierzemy tą liczbę do zmiennej i w zależności od wybranej liczby wyświetlimy komunikat „Wpisales liczbe n, wiec wykonuje kod z czesci case:n”, gdzie pod n będziemy podstawiali liczbę podaną przez użytkownika. No to do dzieła.

#include <iostream>

using namespace std;

int main()
{
    int liczba;
    cout << "Podaj liczbe 1-5 : ";
    cin >> liczba;
    switch(liczba)
    {
    case 1: 
        cout << "Wpisales liczbe 1, wiec wykonuje kod z czesci case:1"; 
        break;
    case 2: 
        cout << "wpisales liczbe 2, wiec wykonuje kod z czesci case:2"; 
        break;
    case 3: 
        cout << "wpisales liczbe 3, wiec wykonuje kod z czesci case:3"; 
        break;
    case 4: 
        cout << "wpisales liczbe 4, wiec wykonuje kod z czesci case:4"; 
        break;
    case 5: 
        cout << "wpisales liczbe 5, wiec wykonuje kod z czesci case:5"; 
        break;
    
    }

    return 0;
}

Przetestujmy nasz program podając liczbę 2 (zrzut poniżej).

 cpp c++ loops switch
Widzimy, że wszystko poszło zgodnie z planem i wykonała się instrukcja dla wartości zmiennej liczba = 2.
A co się stanie jeżeli użytkownik podałby liczbę spoza zakresu np. 6 ? Przetestujmy.
 cpp c++ loops switch
Widzimy, że nic tragicznego się nie stało. Program „poszedł” dalej i nie wyświetlił żadnej instrukcji bo wartość 6 dla zmiennej liczba nie była oprogramowana w switch-u, więc kompilator nie wiedział co ma zrobić. Czasami jednak potrzebujemy oprogramować taką sytuację kiedy chcemy wykonać jakiś kod lub wyświetlić jakiś komunikat dla przypadku który jest inny niż oprogramowaliśmy w switch-u, jak np. u nas kiedy użytkownik podał liczbę 6. Do tego celu służy instrukcja default. Definiujemy ją identycznie jak w przypadku instrukcji case.

default:
   cout << "liczba nie z przedzialu 1-5, wiec nie wykonam zadnego kodu";
   break;

 Stosując instrukcję default mówimy kompilatorowi, że jeżeli nie znajdzie wartości z warunku oprogramowanej w instrukcji case to ma wykonać kod z części default. Dopiszmy tą część kodu do naszego programu i przetestujmy go.

#include <iostream>

using namespace std;

int main()
{
    int liczba;
    cout << "Podaj liczbe 1-5 : ";
    cin >> liczba;
    switch(liczba)
    {
    case 1:
        cout << "Wpisales liczbe 1, wiec wykonuje kod z czesci case:1";
        break;
    case 2:
        cout << "wpisales liczbe 2, wiec wykonuje kod z czesci case:2";
        break;
    case 3:
        cout << "wpisales liczbe 3, wiec wykonuje kod z czesci case:3";
        break;
    case 4:
        cout << "wpisales liczbe 4, wiec wykonuje kod z czesci case:4";
        break;
    case 5:
        cout << "wpisales liczbe 5, wiec wykonuje kod z czesci case:5";
        break;
    default:
        cout << "liczba nie z przedzialu 1-5, wiec nie wykonam zadnego kodu";
        break;
    }
    cout << endl;



    return 0;
}

Uruchamiamy program i wprowadzamy wartość 6.
 cpp c++ loops switch
Widzimy na ekranie komunikat który oprogramowaliśmy dla  warunku default, więc wszystko działa jak należy.

 


c++ kurs programowania obiektowego spis treści 

 

 

C++ kurs podstawy programowania. Instrukcja warunkowa if else.

Instrukcja IF ELSE
Pierwszą z instrukcji warunkowych jaką poznamy jest instrukcja if … else. Definicja if-a poniżej.

if(warunek)
   {    
      // jeżeli warunek jest spełniony, czyli przyjmuje wartość TRUE (prawdy)
      // to wykona się kod pomiędzy tymi klamrami
   }
else
   {
      // w przeciwnym wypadku wykona się ten kod tutaj
      // czyli warunek przyjmuje wartość FALSE (fałsz)
   }

Wróćmy do przykładu z kontrolowaniem prędkości. Jak mogłoby to wyglądać. Postarajmy się to oprogramować. Przyjmijmy, że co chwilę odczytujemy wartość z czujnika prędkości auta. Wartość z czujnika wrzucamy do zmiennej o nazwie aktualna_predkosc. Mamy też oprogramowane dwie funkcje. Pierwsza odcina dopływ paliwa i będzie miała nazwę zamknij_doplyw_paliwa(), a druga otwierająca z powrotem  dopływ paliwa o nazwie otworz_doplyw_paliwa(). Będzie nam potrzebna jeszcze jedna zmienna, nazwiemy ją dopływ_paliwa, zaraz wyjaśnię dlaczego. Nasz kod mógłby wyglądać jak poniżej.

if(aktualna_predkosc >= 200)
   {
      zamknij_doplyw_paliwa();
      doplyw_paliwa = "Z";
   }
else
   {
      // sprawdz czy doplyw zamkniety
      if(doplyw_paliwa == "Z")
         {
            otworz_doplyw_paliwa();
            doplyw_paliwa = "O";
         }
   }

Powyższy kod można przetłumaczyć tak. Jeżeli aktualna_predkosc jest większa lub równa 200, czyli moment kiedy przekroczyliśmy prędkość graniczną 200 km/h, to uruchom funkcję zamknij_doplyw_paliwa() i ustaw zmienną dopływ_paliwa na "Z" (zamknięty). W przeciwnym przypadku, czyli kiedy prędkość jest mniejsza niż 200 km/h, wykonaj kod z części else{}. Ale tutaj mamy drugiego if-a, bo jeszcze musimy sprawdzić czy aktualnie dopływ_paliwa jest zamknięty czy otwarty. Drugiego if-a możemy przetłumaczyć tak. Jeżeli dopływ_paliwa jest zamknięty (czyli nasz poprzednia prędkość była większa niż 200km/h) uruchamiamy funkcję otworz_doplyw_paliwa() i ustawiamy dopływ_paliwa na "O" (otwarty). Jeżeli dopływ_paliwa jest otwarty ("O") to nie robimy nic no bo aktualnie dopływ paliwa jest otwarty więc nie ma potrzeby uruchamiania funkcji otworz_doplyw_paliwa(). Myślę, że już rozumiesz dokładnie działanie instrukcji if… else i po co w ogóle była nam potrzebna zmienna dopływ_paliwa.
Zwróć uwagę, że używając instrukcji if nie musisz za każdym razem korzystać także z konstrukcji if…else możesz skorzystać tylko z if-a.
Jak już zauważyłeś if-y możemy zagnieżdżać, czyli definiować jednego if-a wewnątrz drugiego.
Cały kod programu mógłby wyglądać tak.

#include <iostream>

using namespace std;

void zamknij_doplyw_paliwa()
{
    cout << "Jedziesz jak wariat, zwolnij!" << endl;
    cout << "Zamykam doplyw paliwa!" << endl << endl;
}

void otworz_doplyw_paliwa()
{
    cout << "Widze, ze zwolniles!" << endl;
    cout << "Otwieram doplyw paliwa!" << endl << endl;
}
    int aktualna_predkosc;
    int i; // licznik dla for-a
    string doplyw_paliwa;

int main()
{



    for(i=0;i<=5;i++)
    {
        cout << "Z jaka predkoscia aktualnie jedziesz? : ";
        cin >> aktualna_predkosc;

        if(aktualna_predkosc >= 200)
           {
              zamknij_doplyw_paliwa();
              doplyw_paliwa = "Z";
           }
        else
           {
              // sprawdz czy doplyw zamkniety
              if(doplyw_paliwa == "Z")
                 {
                    otworz_doplyw_paliwa();
                    doplyw_paliwa = "O";
                 }
                 else
                 {
                     cout << "Jedziesz przepisowo, jedz tak dalej!" << endl << endl;
                 }

           }

    }

    cout << "Dziekujemy za skorzystanie z naszej nawigacji";

    return 0;
}


c++ kurs programowania obiektowego spis treści 

 

 

C++ kurs podstawy programowania. Praca z plikami tekstowymi, odczyt.

Odczyt z pliku.
Umiemy już zapisać dane do pliku tekstowego więc przyszedł czas na odczyt danych tych danych. Skoro przed chwilą napisaliśmy program do zapisu danych to pewnie wystarczy trochę go tylko zmodyfikować/przerobić na odczyt danych. Odpowiedź brzmi tak i właśnie taką modyfikację zaraz zrobimy. Przypomnienie listingu dotyczącego zapisu danych do pliku.

Listing

#include <iostream>
#include <fstream>

using namespace std;

string slowkoen, slowkopl;

int main()
{
    fstream moj_plik;
    moj_plik.open("zwierzeta.txt",ios::out | ios::app);

    cout << "Slowko angielskie: ";
    cin >> slowkoen;
    cout << "Polskie tlumaczenie: ";
    cin >> slowkopl;

    moj_plik << slowkoen << endl;
    moj_plik << slowkopl << endl;
    cout << "Slowka zapisane" << endl;

    moj_plik.close();

    return 0;
}

Zaczniemy od zmodyfikowania linii która mówi w jakim trybie otwieramy nasz plik, czy do zapisu czy do odczytu? Skoro atrybut ios::out funkcji open() mówił o tym, że otwieramy plik do zapisu to wystarczy go zmodyfikować na postać ios::in. Atrybut ios::app w ogóle usuwamy bo do naszego zadania nie jest on w ogóle potrzebny. Czyli linia dotycząca dostępu do pliku będzie wyglądała tak.

moj_plik.open( "zwierzeta.txt" , ios::in );

Dobrą praktyką jest sprawdzenie, czy z plikiem jest wszystko w porządku czy nie jest np. uszkodzony? Jeżeli będziemy chcieli odczytać jakieś dane z uszkodzonego pliku, nasz program zakończy się błędem. Do tego celu służy funkcja good(). A sprawdzenie będzie wyglądało tak.

Listing

    if(moj_plik.good()==false)
    {
        cout << "Plik jest uszkodzony!" << endl; // funkcja good() zwrocila falsz
    }
    else
    {
        cout << "Plik jest poprawny!" << endl; // funkcja good() zwrocila prawde
    } 

Funkcja good() zwróci nam wartość fałsz jeżeli plik będzie uszkodzony lub wartość prawda jeżeli z plikiem będzie wszystko OK. Jakby się tak zastanowić to w przypadku poprawnego pliku nie ma potrzeby informowania o tym fakcie użytkownika. Zamiast komunikatu o poprawnym pliku w części else{} będziemy umieszczać kod, który powie komputerowi co ma zrobić w przypadku kiedy z plikiem jest wszystko w porządku.
Skoro z plik jest OK to teraz zamiast zapisywać dane do pliku musimy je odczytać. Do tego celu służy funkcja getline(). Dla tej funkcji podajemy dwa parametry. Pierwszy to do którego pliku chcemy się odwołać (zmienna plikowa), a w drugim (po przecinku) określamy gdzie chcemy zapisać odczytane dane z pliku. Żeby mieć gdzie zapisywać dane z pliku musimy utworzyć zmienną do której będziemy je zapisywali. Stworzymy więc sobie wcześniej zmienną string linia; o typu string (pomiędzy using namespace … funkcją main() ).

string linia;

a następnie w części else{} naszego if-a wrzucimy kod z funkcją getline().

getline(moj_plik, linia);

W tym momencie nasz kod wygląda tak.

Listing

#include <iostream>
#include <fstream>

using namespace std;

string slowkoen, slowkopl;
string linia;

int main()
{
    fstream moj_plik;
    moj_plik.open("zwierzeta.txt",ios::in);

    if(moj_plik.good()==false)
    {
        // funkcja good() zwrocila falsz, blad odczytu
        cout << "Blad odczytu pliku!";
    }
    else
    {
        // funkcja good() zwrocila prawde, czyli z plikiem wszysto OK
        getline(moj_plik,linia);
        cout << linia << endl;
    }

    moj_plik.close();

    return 0;
}

Jak uruchomimy nasz program to zobaczymy na ekranie słówko cat.


cpp c++ kurs podstawy programowania odczyt z pliku tekstowego

Dlaczego tylko słówko cat ? Otóż dlatego, że funkcja getline() pobrała (odczytała) pierwszą linię z naszego pliku i tyle, na razie niczego więcej nie oprogramowaliśmy. Więc, co zrobić żeby można było „przemieszczać” się pomiędzy poszczególnymi liniami?
Każdorazowe wywołanie funkcji getline() skutkuje odczytem aktualnej linii (zaczynając od początku pliku) i przejściem do kolejnej, czyli przy drugim wywołaniu tej funkcji odczytamy drugą linię z pliku itd. W zależności jakie dane odczytujesz, co chcesz z nimi później zrobić i czy wiesz ile plik ma linii, dobierasz metodę do odczytu pliku, ale cały czas korzystasz z funkcji getline(). Weźmy na warsztat nasz plik. Wiemy, że nasz plik przechowuje w kolejnych liniach (na przemian) słówko angielskie i jego polskie tłumaczenie. Aby odczytać dane z pliku moglibyśmy wrzucić poszczególne słówka do tablicy. Wtedy mamy sytuację, że pod indeksami parzystymi (pamiętaj numeracja tablic zaczyna się od 0 a nie od 1) będziemy mieli słówka angielskie a pod indeksami nieparzystymi będziemy mieli słówka polskie. Zawsze polskie tłumaczenie danego angielskiego słówka będzie o indeksie o jeden większym niż słówko angielskie. Oczywiście pomysłów na odczytanie jest pewnie więcej np. wrzucić słówka angielskie do jednej tablicy a polskie od drugiej, wtedy komórki o takim samym indeksie o obu tablicach będą ze sobą związane (słówko angielskie i polskie tłumaczenie). Można też wrzucić słówka do tablicy wielowymiarowej itd. Teraz zajmiemy się tym rozwiązaniem o którym mówiłem na początku, wrzucimy słówka ciągiem do jednej tablicy a później je wypiszemy na ekranie ale już będziemy je pobierać z tablicy a nie z pliku. W tablicach jest tylko jedno ograniczenie, od razu musimy podać długość tej tablicy. Oczywiście możemy to obejść obliczając przed deklaracją tablicy ilość linii w pliku ale nie jest to tematem tej lekcji więc od razu przy deklaracji tablicy wpiszemy odpowiednią jej długość. No to do dzieła.
Do naszego pliku zwierzęta.txt dopisałem jeszcze trzy pozycje, więc w tym momencie mamy już 5 zwierząt: kot, piec, małpa, mysz i koń.
Na początku deklarujemy tablicę, do której wrzucimy słówka z pliku. Zwierząt jest 5 więc słówek jest 10 i tylu elementowej tablicy będziemy potrzebować. Oczywiście tablica będzie przechowywała stringi więc musi być typu string.

string words_all[10];

Teraz standardowa procedura: deklaracja zmiennej plikowej i otwarcie pliku do odczytu.

Listing

// tworzymy zmienną plikową
    fstream file;

    // otwieramy plik do odczytu
    file.open("zwierzeta.txt",ios::in);

    // good() <- sprawdza czy plik OK
    if(file.good()==false)
    {
        // plik NIE jest OK
    }
    else
    {
        // jeżeli plik nie jest uszkodzony to tutaj piszemy dalej kod
    }

Jeżeli w ten sposób „sprawdzamy” czy z plikiem wszystko OK to dalej kod piszemy wewnątrz części else{}. Można by to było oprogramować trochę inaczej.

if(file.good()==false)
    {
        // plik NIE jest OK
       exit(0);  // ale wtedy na górze musisz dodać bibliotekę #include <cstdlib>
    }
    // wtedy nie potrzebujesz części else{}
    // i kod piszesz normalnie poza if-em

Jaką robotę robi tutaj funkcja exit()? Funkcja ta służy do zamknięcia programu (wyjścia z programu). Zwróć uwagę, że uruchamiamy ją (czyli wychodzimy z programu) w momencie kiedy coś jest nie tak z plikiem. Jeżeli np. plik jest uszkodzony nie ma sensu żeby komputer dalej przetwarzał kod i najlepiej wtedy zakończyć program. Wybór metody zależy od Ciebie.
Kod który odczytuje dane z pliku i „wrzuca” je do tablicy poniżej.

// i <- licznik do for'a
        int i=0;
        for( i = 0; i <= 9; i++ )
        {
            getline(file,line);
            words_all[i] = line;
        }

Pętlę for już znamy więc wiemy jak działa. Dlaczego w drugim parametrze w pętli for jest i<=9 ? Skoro numeracja indeksów w tablicy zaczyna się od 0 to od takiej wartości licznika i musimy rozpocząć. Wtedy drugim warunkiem musi być i<=9 bo chcemy wrzucić 10 elementów do tablicy a zaczęliśmy liczyć od 0 więc musimy skończyć na wartości 9.
Znamy już funkcję getline(); i wiemy, że pobiera ona „aktualną” linię do zmiennej line.
Teraz zaczyna się clou sprawy, czyli wrzucanie tych danych do tablicy. Spójrz na zapis.

words_all[i] = line;

Wartość zmiennej line (w danym cyklu pętli for) będziemy wrzucali do kolejnych komórek tablicy words_all[]. Licznik i posłuży nam do odwoływania się do kolejnych elementów (komórek) tablicy. Przy pierwszym cyklu pętli for zmienna i będzie miała wartość 0, czyli powyższe polecenie przyjmie postać words_all[0] =line; co oznacza, że wartość (linia) odczytaną z pliku wrzucimy do komórki o zerowym indeksie w tablicy words_all[]. Przy drugim cyklu, dzięki funkcji getline() w zmiennej line będziemy już mieli odczytaną drugą linię z pliku. Wtedy licznik i dla pętli for przybierze już wartość 1, czyli drugą linię z pliku zapiszemy do komórki o indeksie 1 w tablicy words_all[] itd. Sam widzisz, że to nie jest takie proste. Pętla wykona się 10 razy i wszystkie linie (słówka) z pliku znajdą się w naszej tablicy.
Teraz wystarczy tylko wyświetlić po kolei słówka na ekranie ale już nie z pliku tylko z tablicy, gdzie przed chwilką „wrzuciliśmy” dane z pliku.

Listing

// Odczyt slowek z tablicy
        cout << "Slowka z tablicy words_all:" << endl;
        for( i = 0; i <= 9; i++ )
        {
            cout << words_all[i] << endl;
        }

Sam widzisz, że odczyt z tablicy robimy dokładnie według tego samego schematu gdy zapisywaliśmy do niej dane z tą różnicą że tutaj wywołujemy funkcję cout i odwołujemy się (za każdym „obrotem” pętli) do kolejnych komórek tablicy words_all[].
Cały kod poniżej.

Listing

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

string slowkoen, slowkopl;
string linia;

int main()
{
    // deklarujemy tablice na slowka z pliku
    string words_all[10]; 
   // zm. do zapisywania linii odczytanych w pliku
    string line;

    // tworzymy zmienna plikowa
    fstream file;
    
    // otwieramy plik do odczytu
    file.open("zwierzeta.txt",ios::in);

    // good() <- sprawdza czy plik OK
    if(file.good()==false)
    {
        cout << "Blad odczytu pliku!";
        exit(0);
    }
    else
    {
        // i <- licznik do for'a
        int i=0;
        for( i = 0; i <= 9; i++ )
        {
            getline(file,line);
            words_all[i] = line;
        }

        // Odczyt slowek z tablicy
        cout << "Slowka z tablicy words_all:" << endl;
        for( i = 0; i <= 9; i++ )
        {
            cout << words_all[i] << endl;
        }
    }
    file.close();
    return 0;
}

c++ kurs programowania obiektowego spis treści 

 

 

C++ kurs podstawy programowania. Praca z plikami tekstowymi, zapis.

Dzisiaj poznamy bardzo przydatną rzecz a mianowicie nauczymy się odczytywać dane (tekst) z plików. To bardzo przydatna umiejętność. Pliki tekstowe mogą nawet służyć jako takie mini bazy danych więc sam widzisz, że umiejętność pracy z plikami tekstowymi jest naprawdę ważna i przydatna. Zaczynamy!

Startujemy oczywiście z poziomu pustego projektu Hello world! (listing poniżej).

#include <iostream>

using namespace std;

int main()
{
    cout << "Hello world!" << endl;
    return 0;
}

Stworzymy plik, który kiedyś wykorzystamy do stworzenia programu do nauki języka angielskiego. Będzie on przechowywał w kolejnych liniach najpierw słówko angielskie a w następnej linii jego polskie tłumaczenie. Nazwa pliku będzie odwoływała się do kategorii słówek, które będą się znajdowały wewnątrz pliku. Na początek stworzymy plik, który będzie przechowywał słówka do nauki zwierząt.

Żeby w ogóle pracować z plikami tekstowymi musimy dodać do naszego projektu bibliotekę poleceniem include.

#include <fstream>

Tą linię dodajemy poniżej dodanej biblioteki iostream (poniżej pierwszej linii).

Teraz możemy utworzyć zmienna plikową typu fstream, która będzie nam służyła do odwoływania się do naszego pliku. Tak jak do zapisywania ciągów znaków wykorzystujemy zmienną o typie string tak dla plików tworzymy zmienną plikową o dowolnej nazwie typu fstream.

fstream moj_plik;

Następnie musimy podać komputerowi lokalizację naszego pliku i w jakim trybie chcemy do otworzyć, bo możemy otworzyć plik albo do zapisu albo do odczytu, w sumie logiczne jeżeli chcemy coś do pliku zapisać/lub dopisać albo chcemy coś z niego odczytać. Poniżej kod.

moj_plik.open("zwierzeta.txt",ios::out);

Funkcja open() służy do otwierania pliku. Pierwszy argument w nawiasach, u nas zwierzeta.txt, mówi o ścieżce dostępu do pliku, czyli o lokalizacji pliku na dysku. Tutaj jest tylko sama nazwa pliku więc code::blocks będzie szukał naszego pliku w katalogu z projektem. Co oznacza parametr ios::out. Słówko  ios znaczy input output stream czyli zaznaczamy, że chodzi nam o strumień danych, out oznacza, że ten strumień danych chcemy wyprowadzić z programu do pliku. Znak :: to operator zasięgu mówi tylko tyle, że funkcja out jest częścią składową klasy ios.

Funkcja open() przy próbie otwarcia pliku działa jeszcze w jeden sposób. Sprawdza ona czy w podanej lokalizacji (pierwszy parametr) znajduje się plik o wskazanej przez nas nazwie. Jeżeli tak to otworzy ten plik do zapisu, a jeżeli nie to najpierw utworzy taki plik i otworzy go do zapisu. Fajnie, nawet nie musimy się za bardzo martwić, co w sytuacji kiedy naszego pliku nie ma we wskazanej lokalizacji, funkcja open() załatwi to za nas.

Żeby „wrzucić” jakieś dane do pliku utworzymy sobie dwie zmienne pomocnicze które będą nam przechowywały słówko w języku angielskim i jego tłumaczenie po polsku podane przez użytkownika.

string slowkoen, slowkopl;

Zmienne tworzymy pomiędzy using namespace std; a funkcją main().

Teraz poprosimy użytkownika o wprowadzenie z klawiatury słówka angielskiego i jego polskiego tłumaczenia.

    cout << "Slowko angielskie: ";
    cin >> slowkoen;
    cout << "Polskie tlumaczenie: ";
    cin >> slowkopl;

Czyli w zmiennych slowkoen i slowkopl mamy już słówka które chcemy zapisać w pliku. No to zapisujemy. Sprawa jest bardzo prosta.

    moj_plik << slowkoen << endl;
    moj_plik << slowkopl << endl;

Na początku odwołujesz się do Twojego pliku poprzez zmienną plikową mój_plik a później „wyprowadzasz” z programu dane z tych zmiennych do pliku. Zwróć uwagę, że na końcu każdej linii wywołujemy funkcję endl() („end line”, czyli koniec linii). Gdybyśmy tego nie zrobili to wszystkie dane, angielskie i polskie słówko, zapisałoby się do pliku w jednej linii.

Dodatkowo możemy wyświetlić użytkownikowi komunikat o tym, że słówka zostały zapisane do pliku.

cout << "Slowka zapisane" << endl;

W momencie kiedy już nie będziemy korzystać z pliku należy zamknąć plik.

moj_plik.close();

Cały nasz kod będzie wyglądał jak poniżej.

 

#include <iostream>
#include <fstream>

using namespace std;

string slowkoen, slowkopl;

int main()
{
    fstream moj_plik;
    moj_plik.open("zwierzeta.txt",ios::out);

    cout << "Slowko angielskie: ";
    cin >> slowkoen;
    cout << "Polskie tlumaczenie: ";
    cin >> slowkopl;

    moj_plik << slowkoen << endl;
    moj_plik << slowkopl << endl;
    cout << "Slowka zapisane" << endl;

    moj_plik.close();

    return 0;
}

Po uruchomieniu program pyta użytkownika o podanie słówka angielskiego

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

Po jego podaniu i potwierdzeniu enterem program pyta nas o polskie tłumaczenie podanego słówka.

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

 

Po podaniu polskiego słówka, program wyświetla komunikat do użytkownika, że słówko jest dodane i kończy pracę. Oczywiście code::blocks wyświetla jeszcze swoje powiadomienie o czasie wykonania programu i czeka na wciśnięcie jakiegoś klawisza z klawiatury.

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

Widzimy, że w konsoli wszystko poszło zgodnie z planem, ale czy utworzyliśmy pliki i czy znajdują się w nim dane które wprowadziliśmy. Zobaczmy w katalogu z projektem czy istnieje plik o nazwie zwierzęta.txt.

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

Widzimy, że w katalogu naszego projektu znajduje się plik zwierzęta.txt czyli wszystko wygląda dobrze. Teraz zostało nam do sprawdzenia czy po otwarciu pliku dane które wysłaliśmy do pliku się zapisały.

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

Wszystko zadziałało prawidłowo, w pliku znajdują się dwie linie z zapisanymi słówkami. Ktoś jednak przytomnie spyta co się stanie w przypadku ponownego uruchomienia programu. Czy program dopisze dane do pliku czy je nadpisze. No to uruchamiamy program jeszcze raz.

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

Sprawdzamy co się dzieje w pliku.

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

Widzimy więc, że każde uruchomienie programu powoduje nadpisanie wcześniej wprowadzonych danych. Czy możemy coś z tym zrobić? Oczywiście, że tak. W miejscu gdzie określamy w jakim trybie otwieramy nasz plik musimy dodać parametr mówiący o tym, że chcemy dopisywać dane a nie zastępować. Wystarczy do linii

moj_plik.open("zwierzeta.txt",ios::out);

dodać parametr

moj_plik.open("zwierzeta.txt",ios::out | ios::app);

Sprawdźmy czy działa. Aktualnie w naszym pliku mamy dodanego psa. No to nie może zabraknąć także kota. Uruchamiamy program i dodajemy słówka cat / kot.

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

Sprawdźmy co się stało w naszym plik. Otwieramy plik zwierzęta.txt.

cpp c++ kurs podstawy programowania, progarmowanie obiektowe

Bingo! Pod słówkami dotyczącymi psa dodały się dwie linie dotyczące kota. Oto właśnie nam chodziło. Widzisz więc, że zapisywanie danych do pliku tekstowego to nic trudnego. Finalnie nasz kod przybierze postać.

#include <iostream>
#include <fstream>

using namespace std;

string slowkoen, slowkopl;

int main()
{
    fstream moj_plik;
    moj_plik.open("zwierzeta.txt",ios::out | ios::app);

    cout << "Slowko angielskie: ";
    cin >> slowkoen;
    cout << "Polskie tlumaczenie: ";
    cin >> slowkopl;

    moj_plik << slowkoen << endl;
    moj_plik << slowkopl << endl;
    cout << "Slowka zapisane" << endl;

    moj_plik.close();

    return 0;
}

W kolejnych częściach kursu nauczysz się odczytywać te dane z pliku.


c++ kurs programowania obiektowego spis treści