Początek języka C++ miał miejsce w 1983 roku, wkrótce potem 'Bjare Stroustrup' pracował z klasami w języku C włącznie z kilkoma dodatkowymi funkcjami, takimi jak przeciążanie operatorów. Używane rozszerzenia plików to „.c” i „.cpp”. C++ jest rozszerzalny i niezależny od platformy i zawiera STL, który jest skrótem od standardowej biblioteki szablonów. Tak więc, w zasadzie znany język C++ jest właściwie znany jako język skompilowany, który ma plik źródłowy skompilowany razem w celu utworzenia plików obiektowych, które w połączeniu z linkerem dają uruchamialny program.

Z drugiej strony, jeśli mówimy o jego poziomie, jest to poziom średni, który interpretuje zalety programowania niskopoziomowego, takiego jak sterowniki lub jądra, a także aplikacji wyższego poziomu, takich jak gry, GUI lub aplikacje komputerowe. Ale składnia jest prawie taka sama dla C i C++.

Składniki języka C++:

#include

To polecenie jest plikiem nagłówkowym zawierającym polecenie „cout”. Może istnieć więcej niż jeden plik nagłówkowy w zależności od potrzeb i preferencji użytkownika.

int main()

Ta instrukcja jest główną funkcją programu, która jest warunkiem wstępnym dla każdego programu C++, co oznacza, że ​​bez tej instrukcji nie można wykonać żadnego programu C++. Tutaj „int” jest typem danych zmiennej zwracanej, informującym o typie danych zwracanych przez funkcję.

Deklaracja:

Zmienne są deklarowane i przypisywane im nazwy.

Stwierdzenie problemu:

Jest to niezbędne w programie i może być pętlą „while”, „for” lub dowolnym innym zastosowanym warunkiem.

Operatorzy:

Operatory są używane w programach C++, a niektóre są kluczowe, ponieważ są stosowane do warunków. Kilka ważnych operatorów to &&, ||, !, &, !=, |, &=, |=, ^, ^=.

Dane wejściowe C++:

Teraz omówimy możliwości wejścia i wyjścia w C++. Wszystkie standardowe biblioteki używane w C++ zapewniają maksymalne możliwości wejścia i wyjścia, które są wykonywane w postaci sekwencji bajtów lub są zwykle powiązane ze strumieniami.

Strumień wejściowy:

W przypadku, gdy bajty są przesyłane strumieniowo z urządzenia do pamięci głównej, jest to strumień wejściowy.

Strumień wyjściowy:

Jeśli bajty są przesyłane strumieniowo w przeciwnym kierunku, jest to strumień wyjściowy.

Plik nagłówkowy służy do ułatwienia wprowadzania i wyprowadzania w C++. Jest napisany jako , który udostępnia metody, na przykład gulasz i precyzję ustawiania. Polecenia wejściowe i wyjściowe to cin, cout, cerr i clog. Tutaj „cin” oznacza standardowe wejście, a „cout” oznacza standardowe urządzenie wyjściowe używane z operatorami wstawiania strumienia (<<) do wyświetlania instrukcji na ekranie.

Przykład:

Będziemy wyświetlać wiadomość tekstową za pomocą ciągu znaków.

W pierwszym wierszu dołączamy „iostream”, który zawiera prawie wszystkie niezbędne biblioteki, których możemy potrzebować do wykonania programu w C++. W następnym wierszu deklarujemy przestrzeń nazw, która zapewnia zakres identyfikatorów. Po wywołaniu funkcji main inicjujemy tablicę typów znaków, która przechowuje komunikat tekstowy, a 'cout' wyświetla ją poprzez łączenie. Używamy „cout” do wyświetlania tekstu na ekranie. Wzięliśmy również zmienną „A” mającą tablicę typu danych znaków do przechowywania ciągu znaków, a następnie dodaliśmy zarówno komunikat tablicy wraz z wiadomością statyczną za pomocą polecenia „cout”.

Wygenerowane dane wyjściowe pokazano poniżej:

Przykład:

W tym przypadku wiek użytkownika przedstawilibyśmy w prostym komunikacie tekstowym.

W pierwszym kroku dołączamy bibliotekę. Następnie używamy przestrzeni nazw, która zapewniłaby zakres identyfikatorów. W następnym kroku wzywamy Główny() funkcjonować. Następnie inicjujemy wiek jako zmienną „int”. Używamy polecenia „cin” do wprowadzania i polecenia „cout” do wyświetlania prostego komunikatu tekstowego. „Cin” wprowadza wartość wieku od użytkownika, a „cout” wyświetla ją w innym komunikacie statycznym.

Ten komunikat jest wyświetlany na ekranie po uruchomieniu programu, aby użytkownik mógł uzyskać wiek, a następnie nacisnąć ENTER.

Przykład:

Tutaj pokazujemy, jak wydrukować ciąg znaków za pomocą „cout”.

Aby wydrukować ciąg, najpierw dołączamy bibliotekę, a następnie przestrzeń nazw dla identyfikatorów. The Główny() wywoływana jest funkcja. Ponadto wyświetlamy wynik w postaci ciągu znaków za pomocą polecenia „cout” z operatorem wstawiania, który następnie wyświetla statyczny komunikat na ekranie.

Typy danych C++:

Typy danych w C++ to bardzo ważny i szeroko znany temat, ponieważ stanowią one podstawę języka programowania C++. Podobnie każda użyta zmienna musi być określonego lub zidentyfikowanego typu danych.

Wiemy, że dla wszystkich zmiennych używamy typu danych podczas deklaracji, aby ograniczyć typ danych, który wymagał przywrócenia. Lub możemy powiedzieć, że typy danych zawsze informują zmienną o rodzaju danych, które sama przechowuje. Za każdym razem, gdy definiujemy zmienną, kompilator przydziela pamięć na podstawie zadeklarowanego typu danych, ponieważ każdy typ danych ma inną pojemność pamięci.

Język C++ wspomaga różnorodność typów danych, dzięki czemu programista może wybrać odpowiedni typ danych, którego może potrzebować.

C++ ułatwia korzystanie z poniższych typów danych:

1. Typy danych zdefiniowane przez użytkownika
2. Pochodne typy danych
3. Wbudowane typy danych

Na przykład poniższe wiersze są podane w celu zilustrowania ważności typów danych poprzez inicjalizację kilku typowych typów danych:

Poniżej przedstawiono kilka typowych typów danych: jaki rozmiar określają i jaki rodzaj informacji będą przechowywać ich zmienne:

• Char: o rozmiarze jednego bajta będzie przechowywać pojedynczy znak, literę, liczbę lub wartości ASCII.
• Boolean: Przy rozmiarze 1 bajta przechowuje i zwraca wartości jako prawda lub fałsz.
• Int: Przy rozmiarze 2 lub 4 bajtów będzie przechowywać liczby całkowite, które nie są dziesiętne.
• Zmiennoprzecinkowa: o rozmiarze 4 bajtów przechowuje liczby ułamkowe, które mają jeden lub więcej miejsc po przecinku. Jest to wystarczające do przechowywania do 7 cyfr dziesiętnych.
• Podwójna liczba zmiennoprzecinkowa: o rozmiarze 8 bajtów przechowuje również liczby ułamkowe, które mają jeden lub więcej miejsc dziesiętnych. Jest to wystarczające do przechowywania do 15 cyfr dziesiętnych.
• Void: bez określonego rozmiaru void zawiera coś bezwartościowego. Dlatego jest używany dla funkcji, które zwracają wartość null.
• Szeroki znak: o rozmiarze większym niż 8 bitów, który zwykle ma długość 2 lub 4 bajty, jest reprezentowany przez wchar_t, który jest podobny do char, a zatem przechowuje również wartość znaku.

Wielkość wyżej wymienionych zmiennych może się różnić w zależności od zastosowania programu lub kompilatora.

Przykład:

Napiszmy prosty kod w C++, który da dokładne rozmiary kilku typów danych opisanych powyżej:

W tym kodzie integrujemy bibliotekę . Następnie używamy „przestrzeni nazw”. W następnym wierszu wołamy Główny() funkcja, w której używamy polecenia „cout”, które wypisze rozmiary wszystkich typów danych określonych w programie. Aby znaleźć wielkość zmiennych, musimy zastosować rozmiar() metoda.

Wyjście jest odbierane w bajtach, jak pokazano na rysunku:

Przykład:

Tutaj dodamy rozmiar dwóch różnych typów danych.

Najpierw dołączamy plik nagłówkowy wykorzystujący „standardową przestrzeń nazw” dla identyfikatorów. Następnie Główny() wywoływana jest funkcja, w której najpierw inicjujemy zmienną „int”, a następnie zmienną „double”, aby sprawdzić różnicę między rozmiarami tych dwóch. Następnie ich rozmiary są łączone za pomocą funkcji rozmiar() funkcjonować. Wynik jest wyświetlany w instrukcji „cout”.

Jest jeszcze jeden termin, o którym należy wspomnieć i jest to „Modyfikatory danych” . Nazwa sugeruje, że „modyfikatory danych” są używane wraz z wbudowanymi typami danych do modyfikowania ich długości, które dany typ danych może utrzymać zgodnie z potrzebami lub wymaganiami kompilatora.

Oto modyfikatory danych dostępne w C++:

1. Podpisano
2. Niepodpisany
3. Długie
4. Niski

Zmodyfikowany rozmiar, a także odpowiedni zakres wbudowanych typów danych są wymienione poniżej w połączeniu z modyfikatorami typu danych:

• Krótki int: Mając rozmiar 2 bajtów, ma zakres modyfikacji od -32 768 do 32 767
• Unsigned short int: o rozmiarze 2 bajtów, ma zakres modyfikacji od 0 do 65 535
• Unsigned int: o rozmiarze 4 bajtów, ma zakres modyfikacji od 0 do 4 294 967 295
• Int: o rozmiarze 4 bajtów, ma zakres modyfikacji od -2147 483 648 do 2 147 483 647
• Long int: o rozmiarze 4 bajtów, ma zakres modyfikacji od -2147 483 648 do 2 147 483 647
• Unsigned long int: o rozmiarze 4 bajtów, ma zakres modyfikacji od 0 do 4294967.295
• Long long int: o rozmiarze 8 bajtów, ma zakres modyfikacji od –(2^63) do (2^63)-1
• Unsigned long long int: o rozmiarze 8 bajtów, ma zakres modyfikacji od 0 do 18 446 744 073 709 551 615
• Znak ze znakiem: o rozmiarze 1 bajta, ma zakres modyfikacji od -128 do 127
• Unsigned char: o rozmiarze 1 bajta, ma zakres modyfikacji od 0 do 255.

Wyliczenie C++:

W języku programowania C++ „Enumeration” jest typem danych zdefiniowanym przez użytkownika. Wyliczenie jest deklarowane jako „ wyliczenie” w C++. Służy do przypisywania określonych nazw do dowolnej stałej używanej w programie. Poprawia czytelność i użyteczność programu.

Składnia:

W C++ deklarujemy enumerację w następujący sposób:

Zalety wyliczenia w C++:

Enum może być używany na następujące sposoby:

• Może być często używany w instrukcjach switch case.
• Może używać konstruktorów, pól i metod.
• Może rozszerzyć tylko klasę „enum”, a nie żadną inną klasę.
• Może wydłużyć czas kompilacji.
• Można go przemierzać.

Wady wyliczenia w C++:

Enum ma też kilka wad:

Jeśli raz nazwa zostanie wyliczona, nie może być ponownie użyta w tym samym zakresie.

Na przykład:

Enum nie można zadeklarować do przodu.

Na przykład:

Wyglądają jak imiona, ale są liczbami całkowitymi. Dzięki temu mogą automatycznie konwertować na dowolny inny typ danych.

Na przykład:

Przykład:

W tym przykładzie widzimy użycie wyliczenia C++:

W tym wykonaniu kodu najpierw zaczynamy od #include . to jedna z bogatych bibliotek w C++. Jest to wbudowana biblioteka. Obejmuje strumienie danych wejściowych i wyjściowych . Następnie używamy standardowej przestrzeni nazw. Następnie zadeklarowaliśmy „enum” określoną nazwę jako Przedmiot i przypisaliśmy trzy przedmioty, którymi są matematyka, angielski i urdu. Matematyka ma przypisaną wartość 1. Naszym celem jest wydrukowanie wartości Przedmiotu zadeklarowanych w wyliczeniu. Następnie przywołujemy Główny() funkcjonować. W Główny() mamy cout<<, gdzie „c” oznacza „znak”, a out oznacza „wyjście”. „Cout” służy do wyświetlania danych wyjściowych . << wskazuje operator wstawiania. Używając ‘cout<<’, wypisujemy wartości wyliczeniowe. Następnie użyjemy polecenia „zwróć 0”. To polecenie zwraca wynik w postaci wartości.

Oto nasz wynik wykonanego programu:

Jak widać, mamy wartości Przedmiotu: Matematyka, Urdu, Angielski; czyli 1,2,3.

Przykład:

Oto kolejny przykład, dzięki któremu wyjaśnimy nasze koncepcje dotyczące enum:

W tym programie zaczynamy od zintegrowania pliku nagłówkowego . Jest to wbudowana biblioteka. Obejmuje strumienie danych wejściowych i wyjściowych. Następnie musimy użyć standardowej przestrzeni nazw. Następnie przypisaliśmy wartości enum do stałych, które są graczami. Naszym celem jest pokazanie, czyj jest nad nim. Następnie nazywamy nasze Główny() funkcjonować. w Główny() funkcji przypisaliśmy dwie stałe: Shadab, której wartość wynosi 20 do zmiennej wyliczenia „bowler1”; oraz Afridi, którego wartość wynosi 25 do zmiennej wyliczanej „bowler2”.

Musimy użyć instrukcji if-else . Użyliśmy również operatora porównania wewnątrz wyrażenia „if”, co oznacza, że ​​porównujemy, czy „melonik2” jest większe niż „melonik1”. Następnie wykonywany jest blok „if”, co oznacza, że ​​jest to koniec Afridi. Następnie wpisaliśmy „cout<<”, aby wyświetlić dane wyjściowe. Najpierw wypisujemy oświadczenie „To koniec”. Następnie wartość „melonik2”. Jeśli nie, wywoływany jest blok else, co oznacza, że ​​jest to koniec Shadaba. Następnie, stosując polecenie „cout<<” wyświetlamy stwierdzenie „Koniec z”. Następnie wartość „melonik1”.

Zgodnie z oświadczeniem If-else mamy ponad 25, co stanowi wartość Afridi. Oznacza to, że wartość zmiennej wyliczanej „bowler2” jest większa niż „bowler1”, dlatego wykonywana jest instrukcja „if”.

C++ Jeśli inaczej, Przełącz:

W języku programowania C++ używamy instrukcji „if” i „switch”, aby zmodyfikować przepływ programu. Instrukcje te są wykorzystywane do dostarczania wielu zestawów poleceń do implementacji programu w zależności od rzeczywistej wartości wspomnianych instrukcji. W większości przypadków używamy operatorów jako alternatywy dla wyrażenia „if”. Wszystkie te wyżej wymienione stwierdzenia są zdaniami wyboru, które są znane jako zdania decyzyjne lub warunkowe.

Oświadczenie „jeśli”:

Ta instrukcja służy do testowania danego warunku, gdy masz ochotę zmienić przebieg dowolnego programu. Tutaj, jeśli warunek jest spełniony, program wykona pisemne instrukcje, ale jeśli warunek jest fałszywy, po prostu zakończy działanie. Rozważmy przykład;

Jest to prosta instrukcja „if”, w której inicjujemy zmienną „int” jako 10. Następnie pobierana jest wartość od użytkownika i jest sprawdzana krzyżowo w instrukcji „if”. Jeśli spełnia warunki zastosowane w instrukcji „if”, zostanie wyświetlony wynik.

Ponieważ wybrana cyfra to 40, wyjściem jest wiadomość.

Oświadczenie „Jeżeli-w przeciwnym razie”:

W bardziej złożonym programie, w którym instrukcja „if” zwykle nie współpracuje, używamy instrukcji „if-else”. W danym przypadku używamy instrukcji „if- else” do sprawdzenia zastosowanych warunków.

Najpierw zadeklarujemy zmienną typu danych „int” o nazwie „x”, której wartość jest pobierana od użytkownika. Teraz używamy wyrażenia „if”, gdzie zastosowaliśmy warunek, że jeśli wartość całkowita wprowadzona przez użytkownika wynosi 2. Wynik będzie pożądany i zostanie wyświetlony prosty komunikat „NICE TRY”. W przeciwnym razie, jeśli wpisana liczba nie jest 2, wynik byłby inny.

Gdy użytkownik wpisuje liczbę 2, wyświetlane jest następujące wyjście.

Gdy użytkownik wpisze dowolną inną liczbę z wyjątkiem 2, otrzymamy wynik:

Instrukcja If-else-if:

Zagnieżdżone instrukcje if-else-if są dość złożone i są używane, gdy w tym samym kodzie zastosowano wiele warunków. Zastanówmy się nad tym na innym przykładzie:

Tutaj, po zintegrowaniu pliku nagłówkowego i przestrzeni nazw, zainicjalizowaliśmy wartość zmiennej „m” jako 200. Wartość „m” jest następnie pobierana od użytkownika, a następnie sprawdzana krzyżowo z wieloma warunkami określonymi w programie.

Tutaj użytkownik wybrał wartość 195. Dlatego dane wyjściowe pokazują, że jest to rzeczywista wartość „m”.

Przełącz oświadczenie:

Instrukcja „switch” jest używana w C++ dla zmiennej, która musi zostać przetestowana, jeśli jest równa liście wielu wartości. W instrukcji „switch” identyfikujemy warunki w postaci odrębnych przypadków, a wszystkie przypadki mają przerwę zawartą na końcu każdej instrukcji case. W wielu przypadkach zastosowano odpowiednie warunki i instrukcje z instrukcjami break, które kończą instrukcję switch i przechodzą do instrukcji default w przypadku, gdy żaden warunek nie jest obsługiwany.

Słowo kluczowe „przerwa”:

Instrukcja switch zawiera słowo kluczowe „break”. Zatrzymuje wykonanie kodu w kolejnym przypadku. Wykonanie instrukcji switch kończy się, gdy kompilator C++ natrafi na słowo kluczowe „break”, a kontrolka przejdzie do wiersza następującego po instrukcji switch. Nie ma potrzeby używania instrukcji break w przełączniku. Wykonanie przechodzi do następnej sprawy, jeśli nie jest używane.

W pierwszym wierszu udostępnionego kodu dołączamy bibliotekę. Następnie dodajemy „przestrzeń nazw”. Wzywamy Główny() funkcjonować. Następnie deklarujemy ocenę typu danych znaku jako „F”. Ta ocena może być Twoim życzeniem, a wynik zostanie wyświetlony odpowiednio dla wybranych przypadków. Do uzyskania wyniku zastosowaliśmy instrukcję switch.

Jeśli jako ocenę wybierzemy „F”, wynikiem będzie „powodzenia następnym razem”, ponieważ jest to stwierdzenie, które chcemy wydrukować w przypadku oceny „F”.

Zmieńmy ocenę na X i zobaczmy, co się stanie. Napisałem „X” jako ocenę, a otrzymany wynik jest pokazany poniżej:

Tak więc niewłaściwa wielkość liter w „przełączniku” automatycznie przenosi wskaźnik bezpośrednio do instrukcji default i kończy działanie programu.

Instrukcje if-else i switch mają kilka wspólnych cech:

• Instrukcje te służą do zarządzania sposobem wykonywania programu.
• Oboje oceniają warunek i to określa sposób działania programu.
• Pomimo różnych stylów reprezentacyjnych, mogą być używane w tym samym celu.

Instrukcje if-else i switch różnią się pod pewnymi względami:

• Podczas gdy użytkownik zdefiniował wartości w instrukcjach case „switch”, podczas gdy ograniczenia określają wartości w instrukcjach „if-else”.
• Potrzeba czasu, aby określić, gdzie należy dokonać zmiany, a modyfikowanie stwierdzeń „jeśli-w przeciwnym razie” jest trudne. Z drugiej strony, instrukcje „switch” można łatwo aktualizować, ponieważ można je łatwo modyfikować.
• Aby uwzględnić wiele wyrażeń, możemy użyć wielu stwierdzeń „jeśli-w przeciwnym razie”.

Pętle C++:

Teraz dowiemy się, jak używać pętli w programowaniu w C++. Struktura kontrolna znana jako „pętla” powtarza serię instrukcji. Innymi słowy, nazywa się to strukturą powtarzalną. Wszystkie instrukcje są wykonywane jednocześnie w strukturze sekwencyjnej . Z drugiej strony, w zależności od podanej instrukcji, struktura warunku może wykonać lub pominąć wyrażenie. W określonych sytuacjach może być wymagane wykonanie instrukcji więcej niż jeden raz.

Rodzaje pętli:

Istnieją trzy kategorie pętli:

• Dla pętli
• Podczas pętli
• Rób pętlę

Dla pętli:

Pętla to coś, co powtarza się jak cykl i zatrzymuje się, gdy nie potwierdza podanego warunku. Pętla „for” wielokrotnie implementuje sekwencję instrukcji i kondensuje kod, który radzi sobie ze zmienną pętli. Pokazuje to, że pętla „for” jest specyficznym typem iteracyjnej struktury kontrolnej, która pozwala nam tworzyć pętlę, która jest powtarzana określoną liczbę razy. Pętla pozwoliłaby nam wykonać liczbę „N” kroków za pomocą kodu składającego się z jednej prostej linii. Porozmawiajmy o składni, której będziemy używać do wykonywania pętli „for” w aplikacji.

Składnia wykonania pętli „for”:

Przykład:

Tutaj używamy zmiennej pętli, aby regulować tę pętlę w pętli „for”. Pierwszym krokiem byłoby przypisanie wartości do tej zmiennej, którą określamy jako pętlę. Następnie musimy określić, czy jest ona mniejsza czy większa od wartości licznika. Teraz ma zostać wykonane ciało pętli, a także zmienna pętli zostanie zaktualizowana w przypadku, gdy instrukcja zwróci true. Powyższe kroki są często powtarzane aż do osiągnięcia stanu wyjścia.

• Wyrażenie inicjujące: Najpierw musimy ustawić licznik pętli na dowolną wartość początkową w tym wyrażeniu.
• Wyrażenie testowe : Teraz musimy przetestować dany warunek w podanym wyrażeniu. Jeśli kryteria są spełnione, wykonamy ciało pętli „for” i będziemy kontynuować aktualizację wyrażenia; jeśli nie, musimy przestać.
• Aktualizuj wyrażenie: To wyrażenie zwiększa lub zmniejsza zmienną pętli o określoną wartość po wykonaniu treści pętli.

Przykłady programów w C++ do walidacji pętli „For”:

Przykład:

Ten przykład pokazuje drukowanie wartości całkowitych od 0 do 10.

W tym scenariuszu mamy wypisać liczby całkowite od 0 do 10. Najpierw inicjujemy zmienną losową i z wartością „0”, a następnie parametr warunku, którego już użyliśmy, sprawdza warunek, jeśli i<=10. A kiedy spełni warunek i stanie się spełniony, rozpoczyna się wykonanie pętli „for”. Po wykonaniu, spośród dwóch parametrów inkrementacji lub dekrementacji, zostanie wykonany jeden, w którym dopóki określony warunek i<=10 nie zmieni się w fałsz, wartość zmiennej i jest zwiększana.

Liczba iteracji z warunkiem i<10:

Przykład:

Poniższa instancja wyświetla wartość liczby całkowitej:

W powyższym przypadku zmienna o nazwie 'a' jest inicjowana wartością podaną 50. Warunek jest stosowany, gdy zmienna 'a' jest mniejsza niż 70. Następnie wartość 'a' jest aktualizowana tak, że jest dodawana z 2. Wartość „a” jest następnie rozpoczynana od wartości początkowej, która wynosiła 50, a 2 jest dodawane jednocześnie w całej pętli, aż warunek zwróci fałsz, a wartość „a” zostanie zwiększona od 70 i pętla się zakończy.

Liczba iteracji:

Pętla podczas:

Dopóki zdefiniowany warunek nie zostanie spełniony, może zostać wykonana jedna lub więcej instrukcji. Kiedy iteracja jest z góry nieznana, jest bardzo przydatna. Najpierw warunek jest sprawdzany, a następnie wchodzi do ciała pętli, aby wykonać lub zaimplementować instrukcję.

W pierwszym wierszu dołączamy plik nagłówkowy oraz standardową przestrzeń nazw. Nazywamy Główny() funkcjonować. Tutaj inicjujemy zmienną „a”. W następnym wierszu stosujemy warunek while. W warunku while używamy instrukcji „cout”, aby wyświetlić zapisaną wartość. Następnie używamy operatora inkrementacji, aby zwiększyć liczbę. W ostatniej linii używamy instrukcji „return 0” do zakończenia programu.

Pętla Do-While:

Gdy zdefiniowany warunek jest spełniony, wykonywana jest seria oświadczeń. Najpierw wykonywany jest korpus pętli. Następnie sprawdzany jest warunek, czy jest spełniony, czy nie. Dlatego oświadczenie jest wykonywane raz. Treść pętli jest przetwarzana w pętli „Do-while” przed oceną warunku. Program działa zawsze, gdy spełniony jest wymagany warunek. W przeciwnym razie, gdy warunek jest fałszywy, program kończy działanie.

Tutaj integrujemy plik nagłówkowy . Korzystamy z Główny() funkcji w programie. Następnie inicjujemy cztery liczby całkowite i używamy instrukcji „cin”, aby użytkownik mógł wprowadzić wartość. W następnym wierszu inicjujemy dwie różne liczby całkowite. Stosujemy stwierdzenie „do”. Wewnątrz instrukcji wykorzystujemy dwie funkcje arytmetyczne. Po pierwsze, używamy operatora mnożenia, a po drugie, używamy operatora dodawania. Następnie stosujemy warunek „while” w programie poza instrukcją „do”. Następnie dodajemy instrukcję „cout”, aby wydrukować wynik za pomocą liczby całkowitej „result”. W ostatniej linii, aby zakończyć program, używamy poleceń return 0.

C++ Kontynuuj/Przerwij:

C++ Kontynuuj oświadczenie:

Instrukcja continue jest używana w języku programowania C++, aby uniknąć bieżącego wcielenia pętli, a także przenieść kontrolę do kolejnej iteracji. Podczas pętli instrukcja continue może służyć do pomijania niektórych instrukcji. Jest również używany w pętli w połączeniu z instrukcjami wykonawczymi. Jeśli określony warunek jest prawdziwy, wszystkie instrukcje następujące po instrukcji continue nie są zaimplementowane.

Z pętlą do:

W tym przypadku używamy „pętli for” z instrukcją continue z C++, aby uzyskać wymagany wynik podczas przekazywania określonych wymagań.

Zaczynamy od włączenia biblioteki i użycia „std przestrzeni nazw”. Wtedy wołamy Główny() funkcjonować. Używamy pętli for. Wewnątrz pętli for deklarujemy zmienną „k”, która jest uważana za leżącą między 3 a 8. Używamy warunku, aby kontynuować iterację, nawet jeśli (k = = 5). Następnie użył instrukcji „kontynuuj” po określeniu warunku. Na końcu. aby wyświetlić dane wyjściowe, korzystamy z polecenia „cout” wraz z poleceniem „return 0”.

Z pętlą while:

W trakcie tej demonstracji użyliśmy zarówno instrukcji „while”, jak i C++ „continue”, uwzględniając pewne warunki, aby zobaczyć, jaki rodzaj danych wyjściowych może zostać wygenerowany.

W tym przykładzie ustawiamy warunek, aby dodać liczby tylko do 40. Jeśli wprowadzona liczba całkowita jest liczbą ujemną, pętla „while” zostanie zakończona. Z drugiej strony, jeśli liczba jest większa niż 40, to ta konkretna liczba zostanie pominięta w iteracji.

Dołączymy bibliotekę , wykorzystując „std przestrzeni nazw”, a następnie wywołamy Główny() funkcjonować. Inicjujemy zmienną „s”. W kolejnym kroku deklarowana jest kolejna zmienna „liczba”. Używamy pętli „while”. Teraz określamy warunek, że wymagana wartość będzie wyższa lub równa zero. Aby dodać wszystkie liczby dodatnie, używamy instrukcji „s += number”. Polecenie „cout” zostanie zastosowane, aby wyświetlić komunikat na konsoli „Wprowadź dowolny numer”. Liczbę całkowitą otrzymujemy od użytkownika za pomocą instrukcji „cin”. Posługujemy się również stwierdzeniem „if”. Gdy zdefiniowana liczba jest większa niż 40, pojawi się komunikat. Następnie użyliśmy polecenia „kontynuuj”. Po wykonaniu wszystkich tych kroków zostanie wykonana instrukcja „kontynuuj”. Aby pokazać sumę wszystkich liczb, używamy oświadczenia „cout”.

C++ break Instrukcja:

Za każdym razem, gdy instrukcja break jest używana w pętli w C++, pętla jest natychmiast kończona, a sterowanie programem jest ponownie uruchamiane po instrukcji po pętli. Możliwe jest również zakończenie sprawy w instrukcji „switch”.

Z pętlą do:

Tutaj wykorzystamy pętlę „for” z instrukcją „break”, aby obserwować dane wyjściowe poprzez iterację różnych wartości.

Najpierw dołączamy plik nagłówkowy . Następnie używamy „std przestrzeni nazw”. Po wywołaniu funkcji main() użyliśmy pętli. Tutaj zainicjowalibyśmy zmienną „m”. Zastosujemy warunek, że wartość „m” mieści się między 10 a 20. Warunek „przerwania” zostanie wykonany tak, jakby (m == 17). Aby wydrukować wynik, wykorzystaliśmy „cout”. Następnie zostanie zastosowane polecenie „powrót 0”.

Z pętlą while:

Zamierzamy zastosować pętlę „while” wraz z instrukcją break.

Zaczynamy od zaimportowania biblioteki . Zostanie uwzględniony „std przestrzeni nazw”. W ramach metody main() inicjowane byłyby dwie zmienne „nbr” i „x”. Użyliśmy pętli „while” i przekazaliśmy „true” jako argument. Aby uzyskać wartość od użytkownika, używamy polecenia „cin”. Następnie wykorzystaliśmy stwierdzenie „jeśli”. Wraz z tym stosowany jest warunek „przerwa”, aby określić warunek, jeśli (nbr < 0). Aby dodać wszystkie wartości dodatnie, wykorzystaliśmy formułę „x += nbr”. Aby wyświetlić tę sumę, dodaliśmy oświadczenie „cout”.

Funkcje C++:

Funkcje służą do strukturyzowania już znanego programu na wiele fragmentów kodu, które są wykonywane tylko wtedy, gdy są wywoływane. W języku programowania C++ funkcję definiuje się jako grupę instrukcji, które otrzymują odpowiednią nazwę i są przez nie wywoływane. Użytkownik może przekazywać dane do funkcji, które wywołujemy parametrami. Funkcje są odpowiedzialne za implementację akcji, gdy istnieje największe prawdopodobieństwo ponownego użycia kodu.

Utworzenie funkcji:

Chociaż C++ dostarcza wiele predefiniowanych funkcji, takich jak Główny(), co ułatwia wykonanie kodu. W ten sam sposób możesz tworzyć i definiować swoje funkcje zgodnie ze swoimi wymaganiami. Podobnie jak wszystkie zwykłe funkcje, tutaj potrzebujesz nazwy swojej funkcji dla deklaracji, która jest dodawana z nawiasem po „()”.

Składnia:

Void to zwracany typ funkcji. Labor to nazwa nadana jej, a nawiasy klamrowe zamykają ciało funkcji, w której dodajemy kod do wykonania.

Wywołanie funkcji:

Funkcje zadeklarowane w kodzie są wykonywane tylko wtedy, gdy są wywoływane. Aby wywołać funkcję, musisz podać nazwę funkcji wraz z nawiasem, po którym następuje średnik „;”.

Przykład:

W tej sytuacji zadeklarujmy i zbudujmy funkcję zdefiniowaną przez użytkownika.

Początkowo, jak opisano w każdym programie, przypisana jest nam biblioteka i przestrzeń nazw do wspomagania wykonywania programu. Funkcja zdefiniowana przez użytkownika praca() jest zawsze wywoływana przed zapisaniem Główny() funkcjonować. Funkcja o nazwie praca() jest deklarowana, gdy wyświetlany jest komunikat „Praca zasługuje na szacunek!”. w Główny() funkcja o zwracanym typie całkowitym, wywołujemy praca() funkcjonować.

Jest to prosta wiadomość, która została zdefiniowana w funkcji zdefiniowanej przez użytkownika wyświetlanej tutaj za pomocą Główny() funkcjonować.

Próżnia:

W wyżej wymienionym przypadku zauważyliśmy, że typ zwracany przez funkcję zdefiniowaną przez użytkownika jest void. Oznacza to, że funkcja nie zwraca żadnej wartości. Oznacza to, że wartość nie jest obecna lub prawdopodobnie ma wartość NULL. Ponieważ za każdym razem, gdy funkcja tylko wyświetla komunikaty, nie potrzebuje żadnej wartości zwracanej.

Ta pustka jest podobnie używana w przestrzeni parametrów funkcji, aby wyraźnie stwierdzić, że ta funkcja nie przyjmuje żadnej rzeczywistej wartości podczas jej wywoływania. W powyższej sytuacji nazwalibyśmy również praca() pełnią funkcję:

Rzeczywiste parametry:

Można zdefiniować parametry funkcji. Parametry funkcji są zdefiniowane na liście argumentów funkcji, która jest dodawana do nazwy funkcji. Za każdym razem, gdy wywołujemy funkcję, musimy przekazać prawdziwe wartości parametrów, aby zakończyć wykonanie. Są one określane jako parametry rzeczywiste. Natomiast parametry, które są zdefiniowane podczas definiowania funkcji, są znane jako parametry formalne.

Przykład:

W tym przykładzie mamy zamiar wymienić lub podstawić dwie wartości całkowite za pomocą funkcji.

Na początku pobieramy plik nagłówkowy. Funkcja zdefiniowana przez użytkownika to zadeklarowana i zdefiniowana nazwana pod(). Ta funkcja służy do podstawienia dwóch wartości całkowitych, którymi są i oraz n. Następnie do wymiany tych dwóch liczb całkowitych używa się operatorów arytmetycznych. Wartość pierwszej liczby całkowitej „i” jest przechowywana w miejscu wartości „n”, a wartość n jest zapisywana w miejscu wartości „i”. Następnie drukowany jest wynik po przełączeniu wartości. Jeśli mówimy o Główny() funkcji, pobieramy wartości dwóch liczb całkowitych od użytkownika i wyświetlamy. W ostatnim kroku funkcja zdefiniowana przez użytkownika pod() jest wywoływana i obie wartości są wymieniane.

W tym przypadku podstawienia tych dwóch liczb wyraźnie widać, że używając pod() funkcji, wartości „i” i „n” wewnątrz listy parametrów są parametrami formalnymi. Rzeczywiste parametry to parametr, który przechodzi na końcu Główny() funkcja, w której wywoływana jest funkcja podstawienia.

Wskaźniki C++:

Wskaźnik w C++ jest łatwiejszy do nauczenia i świetny w użyciu. W języku C++ wskaźniki są używane, ponieważ ułatwiają nam pracę, a wszystkie operacje działają z dużą wydajnością, gdy zaangażowane są wskaźniki. Ponadto istnieje kilka zadań, które nie zostaną wykonane, jeśli nie zostaną użyte wskaźniki, takie jak dynamiczna alokacja pamięci. Mówiąc o wskaźnikach, główną ideą, którą należy zrozumieć, jest to, że wskaźnik jest po prostu zmienną, która będzie przechowywać dokładny adres pamięci jako swoją wartość. Szerokie użycie wskaźników w C++ wynika z następujących powodów:

• Przekazywać jedną funkcję do drugiej.
• Aby przydzielić nowe obiekty na stercie.
• Do iteracji elementów w tablicy

Zwykle operator „&” (ampersand) służy do uzyskania dostępu do adresu dowolnego obiektu w pamięci.

Wskaźniki i ich rodzaje:

Wskaźnik ma kilka typów:

• Zerowe wskaźniki: Są to wskaźniki o wartości zero przechowywane w bibliotekach C++.
• Wskaźnik arytmetyczny: Zawiera cztery główne operatory arytmetyczne, które są dostępne: ++, –, +, -.
• Tablica wskaźników: Są to tablice używane do przechowywania niektórych wskaźników.
• Wskaźnik do wskaźnika: Jest to miejsce, w którym wskaźnik jest używany nad wskaźnikiem.

Przykład:

Zastanów się nad kolejnym przykładem, w którym drukowane są adresy kilku zmiennych.

Po dołączeniu pliku nagłówkowego i standardowej przestrzeni nazw inicjujemy dwie zmienne. Jedna to wartość całkowita reprezentowana przez i’, a druga to tablica znaków ‘I’ o rozmiarze 10 znaków. Adresy obu zmiennych są następnie wyświetlane za pomocą polecenia „cout”.

Dane wyjściowe, które otrzymaliśmy, pokazano poniżej:

Ten wynik pokazuje adres dla obu zmiennych.

Z drugiej strony wskaźnik jest uważany za zmienną, której wartością jest adres innej zmiennej. Wskaźnik zawsze wskazuje na typ danych, który ma ten sam typ, który jest tworzony za pomocą operatora (*).

Deklaracja wskaźnika:

Wskaźnik jest deklarowany w ten sposób:

Podstawowy typ wskaźnika jest oznaczony przez „type”, podczas gdy nazwa wskaźnika jest wyrażona przez „var-name”. A do zatytułowania zmiennej do wskaźnika używana jest gwiazdka (*).

Sposoby przypisywania wskaźników do zmiennych:

Prawie zawsze istnieje długa liczba szesnastkowa reprezentująca adres pamięci, który jest początkowo taki sam dla wszystkich wskaźników, niezależnie od ich typów danych.

Przykład:

Poniższy przykład zademonstruje, w jaki sposób wskaźniki zastępują operator „&” i przechowują adres zmiennych.

Zamierzamy zintegrować obsługę bibliotek i katalogów. Wtedy będziemy przywoływać Główny() funkcja, w której najpierw deklarujemy i inicjujemy zmienną „n” typu „int” o wartości 55. W następnym wierszu inicjujemy zmienną wskaźnikową o nazwie „p1”. Następnie przypisujemy adres zmiennej „n” wskaźnikowi „p1”, a następnie pokazujemy wartość zmiennej „n”. Wyświetlany jest adres „n”, który jest przechowywany we wskaźniku „p1”. Następnie wartość „*p1” jest drukowana na ekranie za pomocą polecenia „cout”. Dane wyjściowe są następujące:

Tutaj widzimy, że wartość „n” wynosi 55, a adres „n”, który był przechowywany we wskaźniku „p1”, jest pokazany jako 0x6ffe14. Znaleziona została wartość zmiennej wskaźnikowej i wynosi ona 55, czyli jest taka sama jak wartość zmiennej całkowitej. Dlatego wskaźnik przechowuje adres zmiennej, a także wskaźnik * ma zapisaną wartość liczby całkowitej, która w rezultacie zwróci wartość początkowo zapisanej zmiennej.

Przykład:

Rozważmy inny przykład, w którym używamy wskaźnika przechowującego adres ciągu.

W tym kodzie najpierw dodajemy biblioteki i przestrzeń nazw. w Główny() funkcji musimy zadeklarować ciąg o nazwie „makeup”, który ma w sobie wartość „Mascara”. Wskaźnik typu string „*p2” jest używany do przechowywania adresu zmiennej makeup. Wartość zmiennej „makeup” jest następnie wyświetlana na ekranie za pomocą instrukcji „cout”. Następnie wypisywany jest adres zmiennej „makeup”, a na końcu wyświetlana jest zmienna wskaźnikowa „p2” pokazująca adres pamięci zmiennej „makeup” ze wskaźnikiem.

Dane wyjściowe otrzymane z powyższego kodu są następujące:

W pierwszym wierszu wyświetlana jest wartość zmiennej „makeup”. Drugi wiersz pokazuje adres zmiennej „makeup”. W ostatniej linii pokazany jest adres pamięci zmiennej „makeup” za pomocą wskaźnika.

Zarządzanie pamięcią C++:

Dla efektywnego zarządzania pamięcią w C++ wiele operacji jest pomocnych w zarządzaniu pamięcią podczas pracy w C++. Kiedy używamy C++, najczęściej używaną procedurą alokacji pamięci jest dynamiczna alokacja pamięci, w której pamięci są przypisywane do zmiennych w czasie wykonywania; nie tak jak inne języki programowania, w których kompilator mógł przydzielić pamięć zmiennym. W C++ cofanie alokacji zmiennych, które były alokowane dynamicznie, jest konieczne, aby pamięć była zwalniana, gdy zmienna nie jest już używana.

W przypadku dynamicznej alokacji i cofnięcia alokacji pamięci w C++ wykonujemy „ Nowy' oraz 'kasować' operacje. Zarządzanie pamięcią ma kluczowe znaczenie, aby nie marnować pamięci. Alokacja pamięci staje się łatwa i efektywna. W każdym programie C++ pamięć jest wykorzystywana w jednym z dwóch aspektów: jako sterta lub stos.

• Stos : Wszystkie zmienne zadeklarowane wewnątrz funkcji i każdy inny szczegół, który jest powiązany z funkcją, jest przechowywany na stosie.
• Sterta : Jakikolwiek rodzaj nieużywanej pamięci lub część, z której alokujemy lub przypisujemy pamięć dynamiczną podczas wykonywania programu, jest znana jako sterta.

Podczas korzystania z tablic alokacja pamięci jest zadaniem, w którym po prostu nie możemy określić pamięci, chyba że w czasie wykonywania. Tak więc przypisujemy maksymalną pamięć do tablicy, ale nie jest to również dobra praktyka, ponieważ w większości przypadków pamięć pozostaje niewykorzystana i jest w jakiś sposób marnowana, co po prostu nie jest dobrą opcją ani praktyką dla twojego komputera osobistego. Dlatego mamy kilka operatorów, które służą do przydzielania pamięci ze sterty w czasie wykonywania. Dwa główne operatory „nowy” i „usuń” są używane do wydajnej alokacji pamięci i cofania alokacji.

Nowy operator C++:

Nowy operator odpowiada za alokację pamięci i jest używany w następujący sposób:

W tym kodzie dołączamy bibliotekę i przestrzeń nazw. Następnie zainicjalizowaliśmy wskaźnik z typem danych „int”. W następnym wierszu temu wskaźnikowi przydzielono operator „nowy”.

Pamięć została pomyślnie przydzielona do zmiennej „int” za pomocą wskaźnika.

Operator usuwania C++:

Za każdym razem, gdy skończymy używać zmiennej, musimy zwolnić pamięć, którą kiedyś przydzieliliśmy, ponieważ nie jest już używana. W tym celu używamy operatora „usuń”, aby zwolnić pamięć.

Przykład, który teraz sprawdzimy, zawiera oba operatory.

Obliczamy średnią dla trzech różnych wartości pobranych od użytkownika. Zmiennym wskaźnikowym jest przypisywany operator „nowy” do przechowywania wartości. Zaimplementowano formułę średniej. Następnie używany jest operator „usuń”, który usuwa wartości przechowywane w zmiennych wskaźnikowych za pomocą operatora „nowy”. Jest to alokacja dynamiczna, w której alokacja jest dokonywana w czasie wykonywania, a następnie cofanie alokacji następuje wkrótce po zakończeniu programu.

Wykorzystanie tablicy do alokacji pamięci:

Teraz zobaczymy, w jaki sposób operatory „nowy” i „usuń” są używane podczas korzystania z tablic. Alokacja dynamiczna odbywa się w taki sam sposób, jak w przypadku zmiennych, ponieważ składnia jest prawie taka sama.

W danym przypadku rozważamy tablicę elementów, których wartość jest pobierana od użytkownika. Pobierane są elementy tablicy i deklarowana jest zmienna wskaźnikowa, a następnie alokowana jest pamięć. Niedługo po przydzieleniu pamięci uruchamiana jest procedura wprowadzania elementów tablicy. Następnie dane wyjściowe dla elementów tablicy są wyświetlane za pomocą pętli „for”. Ta pętla ma warunek iteracji elementów o rozmiarze mniejszym niż rzeczywisty rozmiar tablicy reprezentowanej przez n.

Gdy wszystkie elementy zostaną wykorzystane i nie ma dalszego wymogu ich ponownego użycia, pamięć przypisana do elementów zostanie cofnięta za pomocą operatora „delete”.

Na wyjściu mogliśmy zobaczyć zestawy wartości drukowane dwukrotnie. Pierwsza pętla „for” służyła do zapisywania wartości elementów, a druga pętla „for” służyła do drukowania już zapisanych wartości, pokazując, że użytkownik zapisał te wartości dla przejrzystości.

Zalety:

Operator „nowy” i „usuń” jest zawsze priorytetem w języku programowania C++ i jest szeroko stosowany. Po dokładnym omówieniu i zrozumieniu można zauważyć, że „nowy” operator ma zbyt wiele zalet. Zalety operatora „nowy” dla alokacji pamięci są następujące:

• Nowy operator może z większą łatwością zostać przeciążony.
• Podczas przydzielania pamięci w czasie wykonywania, gdy nie ma wystarczającej ilości pamięci, zostanie zgłoszony automatyczny wyjątek, a nie tylko zakończenie programu.
• Pośpiechu przy użyciu procedury rzutowania typów nie ma tutaj, ponieważ operator „nowy” ma ten sam typ, co pamięć, którą przydzieliliśmy.
• Operator „nowy” odrzuca również pomysł użycia operatora sizeof(), ponieważ „nowy” nieuchronnie obliczy rozmiar obiektów.
• Operator „nowy” umożliwia nam inicjalizację i deklarację obiektów, mimo że spontanicznie generuje dla nich przestrzeń.

Tablice C++:

Przeprowadzimy dogłębną dyskusję na temat tego, czym są tablice oraz jak są deklarowane i implementowane w programie C++. Tablica jest strukturą danych używaną do przechowywania wielu wartości w jednej zmiennej, zmniejszając w ten sposób konieczność samodzielnego deklarowania wielu zmiennych.

Deklaracja tablic:

Aby zadeklarować tablicę, należy najpierw zdefiniować typ zmiennej i nadać jej odpowiednią nazwę, która jest następnie dodawana w nawiasach kwadratowych. Będzie zawierać liczbę elementów pokazujących rozmiar konkretnej tablicy.

Na przykład:

Ta zmienna jest zadeklarowana pokazując, że zawiera pięć ciągów w tablicy o nazwie „makeup”. Aby zidentyfikować i zilustrować wartości dla tej tablicy, musimy użyć nawiasów klamrowych, z każdym elementem oddzielnie ujętym w podwójne cudzysłowy, każdy oddzielony pojedynczym przecinkiem pomiędzy nimi.

Na przykład:

Podobnie, jeśli masz ochotę utworzyć kolejną tablicę z innym typem danych, który ma być „int”, procedura będzie taka sama, wystarczy zmienić typ danych zmiennej, jak pokazano poniżej:

Przypisując do tablicy wartości całkowite, nie wolno umieszczać ich w cudzysłowie, co działałoby tylko dla zmiennej łańcuchowej. Tak więc ostatecznie tablica jest zbiorem powiązanych ze sobą elementów danych z przechowywanymi w nich pochodnymi typami danych.

Jak uzyskać dostęp do elementów w tablicy?

Wszystkim elementom zawartym w tablicy przypisywany jest odrębny numer, który jest ich indeksem, który służy do dostępu do elementu z tablicy. Wartość indeksu zaczyna się od 0 aż do jednego mniej niż rozmiar tablicy. Pierwsza wartość ma wartość indeksu 0.

Przykład:

Rozważ bardzo prosty i łatwy przykład, w którym zainicjujemy zmienne w tablicy.

W pierwszym kroku dołączamy plik nagłówkowy , który automatycznie doda wszystkie potrzebne biblioteki w programie. Przestrzeń nazw „std” zapewni zakres katalogów. W trzecim wierszu nazywamy Główny() funkcjonować. Nawias klamrowy oznacza początek funkcji. Po wejściu do funkcji zadeklarujemy tablicę typu „int” o nazwie „cyfry”. Zawiera rozmiar 4, co oznacza, że ​​może zawierać tylko 4 wartości całkowite na raz. Każdemu z elementów tablicy przypisano osobno unikalną i inną cyfrę. Cała tablica jest następnie wyświetlana, a każdy element jest wywoływany indywidualnie.

To jest wynik otrzymany z powyższego kodu. Słowo kluczowe „endl” automatycznie przenosi drugi element do następnej linii.

Przykład:

W tym kodzie używamy pętli „for” do drukowania elementów tablicy.

W powyższym przypadku dodajemy podstawową bibliotekę. Dodawana jest standardowa przestrzeń nazw. The Główny() function to funkcja, w której zamierzamy wykonać wszystkie funkcjonalności potrzebne do wykonania konkretnego programu. Następnie deklarujemy tablicę typu int o nazwie „Num”, która ma rozmiar 10. Wartość tych dziesięciu zmiennych jest pobierana od użytkownika za pomocą pętli „for”. Do wyświetlenia tej tablicy ponownie wykorzystywana jest pętla „for”. 10 liczb całkowitych przechowywanych w tablicy jest wyświetlanych za pomocą instrukcji „cout”.

To jest wynik, który otrzymaliśmy z wykonania powyższego kodu, pokazujący 10 liczb całkowitych o różnych wartościach.

Przykład:

W tym scenariuszu mamy zamiar poznać średni wynik ucznia i procent, który uzyskał w klasie.

Najpierw musisz dodać bibliotekę, która zapewni początkowe wsparcie dla programu C++. Następnie określamy rozmiar 5 tablicy o nazwie „Score”. Następnie zainicjalizowaliśmy zmienną „sum” typu danych float. Wyniki każdego przedmiotu są pobierane od użytkownika ręcznie. Następnie pętla „for” służy do określenia średniej i procentu wszystkich uwzględnionych przedmiotów. Sumę uzyskuje się za pomocą tablicy i pętli „for”. Następnie średnią wyznacza się za pomocą wzoru na średnią. Po ustaleniu średniej przekazujemy jej wartość do procentu, który jest dodawany do wzoru, aby uzyskać procent. Następnie oblicza się i wyświetla średnią i procent.

Jest to końcowy wynik, w którym wyniki są pobierane od użytkownika dla każdego przedmiotu indywidualnie, a średnia i procent są obliczane odpowiednio.

Zalety korzystania z tablic:

• Pozycje w tablicy są łatwo dostępne ze względu na przypisany im numer indeksu.
• Możemy łatwo przeprowadzić operację wyszukiwania po tablicy.
• Jeśli chcesz złożoność programowania, możesz użyć 2-wymiarowej tablicy, która również charakteryzuje macierze.
• Aby przechowywać wiele wartości o podobnym typie danych, można łatwo wykorzystać tablicę.

Wady korzystania z tablic:

• Tablice mają stały rozmiar.
• Tablice są jednorodne, co oznacza, że ​​przechowywany jest tylko jeden typ wartości.
• Tablice przechowują dane w pamięci fizycznej indywidualnie.
• Proces wstawiania i usuwania nie jest łatwy w przypadku tablic.

Obiekty i klasy C++:

C++ to język programowania obiektowego, co oznacza, że ​​obiekty odgrywają istotną rolę w C++. Mówiąc o obiektach, należy najpierw zastanowić się, czym są obiekty, więc obiekt to dowolna instancja klasy. Ponieważ C++ zajmuje się koncepcjami OOP, głównymi rzeczami do omówienia są obiekty i klasy. Klasy są w rzeczywistości typami danych, które są definiowane przez samego użytkownika i są przeznaczone do enkapsulacji składowych danych i funkcji, które są dostępne tylko w przypadku tworzenia instancji dla określonej klasy. Członkami danych są zmienne zdefiniowane wewnątrz klasy.

Innymi słowy, klasa to zarys lub projekt, który jest odpowiedzialny za definicję i deklarację członków danych oraz funkcji przypisanych do tych członków danych. Każdy z obiektów zadeklarowanych w klasie będzie mógł dzielić wszystkie cechy lub funkcje zademonstrowane przez klasę.

Załóżmy, że istnieje klasa o nazwie ptaki, teraz początkowo wszystkie ptaki mogą latać i mieć skrzydła. Dlatego latanie jest zachowaniem, które te ptaki przyjmują, a skrzydła są częścią ich ciała lub podstawową cechą.

Definiowanie klasy:

Aby zdefiniować klasę, musisz sprawdzić składnię i zresetować ją zgodnie z klasą. Słowo kluczowe „class” służy do definiowania klasy, a wszystkie inne elementy danych i funkcje są zdefiniowane w nawiasach klamrowych, po których następuje definicja klasy.

Deklarowanie obiektów:

Niedługo po zdefiniowaniu klasy, musimy stworzyć obiekty do dostępu i zdefiniować funkcje, które zostały określone przez klasę. W tym celu musimy wpisać nazwę klasy, a następnie nazwę obiektu do deklaracji.

Dostęp do członków danych:

Dostęp do funkcji i członków danych uzyskuje się za pomocą prostego operatora kropki „.”. Dostęp do publicznych członków danych również uzyskuje się za pomocą tego operatora, ale w przypadku prywatnych członków danych po prostu nie można uzyskać do nich bezpośredniego dostępu. Dostęp członków danych zależy od kontroli dostępu nadanej im przez modyfikatory dostępu, które są prywatne, publiczne lub chronione. Oto scenariusz, który pokazuje, jak zadeklarować prostą klasę, składowe danych i funkcje.

Przykład:

W tym przykładzie zdefiniujemy kilka funkcji i za pomocą obiektów uzyskamy dostęp do funkcji klasy i składowych danych.

W pierwszym kroku integrujemy bibliotekę, po czym musimy dołączyć katalogi pomocnicze. Klasa jest jawnie zdefiniowana przed wywołaniem Główny() funkcjonować. Ta klasa nazywana jest „pojazdem”. Członkami danych były „nazwa pojazdu” i „id” tego pojazdu, który jest numerem rejestracyjnym dla tego pojazdu posiadającego odpowiednio string i int datatype. Te dwie funkcje są zadeklarowane dla tych dwóch członków danych. The ID() funkcja wyświetla identyfikator pojazdu. Ponieważ dane należące do klasy są publiczne, możemy również uzyskać do nich dostęp poza klasą. Dlatego nazywamy Nazwa() funkcji poza klasą, a następnie pobranie wartości „Nazwa pojazdu” od użytkownika i wydrukowanie jej w następnym kroku. w Główny() funkcji, deklarujemy obiekt wymaganej klasy, który pomoże w dostępie do składowych danych i funkcji z tej klasy. Ponadto inicjujemy wartości nazwy pojazdu i jego identyfikatora tylko wtedy, gdy użytkownik nie poda wartości nazwy pojazdu.

Jest to wyjście otrzymywane, gdy użytkownik sam nada nazwę pojazdu, a tablice rejestracyjne są przypisaną mu wartością statyczną.

Mówiąc o definicji funkcji składowych, należy zrozumieć, że nie zawsze jest konieczne zdefiniowanie funkcji wewnątrz klasy. Jak widać w powyższym przykładzie, definiujemy funkcję klasy poza klasą, ponieważ składowe danych są publicznie deklarowane i odbywa się to za pomocą operatora rozpoznawania zakresu pokazanego jako '::' wraz z nazwą klasę i nazwę funkcji.

Konstruktory i destruktory C++:

Za pomocą przykładów przyjrzymy się dokładnie temu tematowi. Usuwanie i tworzenie obiektów w programowaniu C++ są bardzo ważne. W tym celu za każdym razem, gdy tworzymy instancję dla klasy, w kilku przypadkach automatycznie wywołujemy metody konstruktora.

Konstruktorzy:

Jak sama nazwa wskazuje, konstruktor wywodzi się od słowa „konstrukcja”, które określa tworzenie czegoś. Konstruktor jest więc definiowany jako funkcja pochodna nowo utworzonej klasy, która ma tę samą nazwę. I jest używany do inicjalizacji obiektów zawartych w klasie. Ponadto konstruktor nie ma wartości zwracanej dla siebie, co oznacza, że ​​jego zwracany typ również nie będzie nawet nieważny. Akceptacja argumentów nie jest obowiązkowa, ale w razie potrzeby można je dodać. Konstruktory są przydatne przy przydzielaniu pamięci obiektowi klasy i ustawianiu wartości początkowej dla zmiennych składowych. Wartość początkowa może zostać przekazana w postaci argumentów do funkcji konstruktora po zainicjowaniu obiektu.

Składnia:

Rodzaje konstruktorów:

Konstruktor sparametryzowany:

Jak wspomniano wcześniej, konstruktor nie ma żadnego parametru, ale można dodać dowolny parametr. Spowoduje to zainicjowanie wartości obiektu podczas jego tworzenia. Aby lepiej zrozumieć tę koncepcję, rozważmy następujący przykład:

Przykład:

W tym przypadku stworzylibyśmy konstruktor klasy i zadeklarowali parametry.

W pierwszym kroku dołączamy plik nagłówkowy. Kolejnym krokiem korzystania z przestrzeni nazw jest obsługa katalogów w programie. Klasa o nazwie „cyfry” jest deklarowana, gdzie najpierw zmienne są publicznie inicjowane, aby były dostępne w całym programie. Zadeklarowana jest zmienna o nazwie „dig1” z typem danych typu integer. Następnie zadeklarowaliśmy konstruktor, którego nazwa jest zbliżona do nazwy klasy. Ten konstruktor ma zmienną całkowitą przekazaną do niego jako „n”, a zmienna klasy „dig1” jest ustawiona na n. w Główny() funkcji programu, tworzone są trzy obiekty dla klasy „cyfry”, którym przypisuje się losowe wartości. Obiekty te są następnie wykorzystywane do wywoływania zmiennych klas, którym automatycznie przypisywane są te same wartości.

Wartości całkowite są prezentowane na ekranie jako dane wyjściowe.

Konstruktor kopiujący:

Jest to typ konstruktora, który traktuje obiekty jako argumenty i duplikuje wartości elementów danych jednego obiektu do drugiego. Dlatego te konstruktory są używane do deklarowania i inicjowania jednego obiektu z drugiego. Ten proces nazywa się inicjalizacją kopii.

Przykład:

W takim przypadku zostanie zadeklarowany konstruktor kopiujący.

Najpierw integrujemy bibliotekę i katalog. Zadeklarowana jest klasa o nazwie „New”, w której liczby całkowite są inicjowane jako „e” i „o”. Konstruktor jest upubliczniany, gdy dwie zmienne mają przypisane wartości, a te zmienne są zadeklarowane w klasie. Następnie wartości te są wyświetlane za pomocą Główny() funkcja z „int” jako typem zwracanym. The wyświetlacz() funkcja jest wywoływana i definiowana później, gdy liczby są wyświetlane na ekranie. W środku Główny() funkcji, obiekty są tworzone, a te przypisane obiekty są inicjowane losowymi wartościami, a następnie wyświetlacz() stosowana jest metoda.

Dane wyjściowe otrzymane przez użycie konstruktora kopiującego są przedstawione poniżej.

Niszczyciele:

Jak sama nazwa wskazuje, destruktory służą do niszczenia utworzonych obiektów przez konstruktora. Porównywalne do konstruktorów, destruktory mają taką samą nazwę jak klasa, ale z dodatkową tyldą (~).

Składnia:

Destruktor nie przyjmuje żadnych argumentów, a nawet nie zwraca żadnej wartości. Kompilator niejawnie odwołuje się do wyjścia z programu, aby wyczyścić pamięć masową, która nie jest już dostępna.

Przykład:

W tym scenariuszu używamy destruktora do usuwania obiektu.

Tutaj powstaje klasa „Buty”. Tworzony jest konstruktor, który ma nazwę podobną do nazwy klasy. W konstruktorze wyświetlany jest komunikat, w którym tworzony jest obiekt. Po konstruktorze tworzony jest destruktor, który usuwa obiekty utworzone za pomocą konstruktora. w Główny() tworzony jest obiekt wskaźnika o nazwie „s”, a do usunięcia tego obiektu używane jest słowo kluczowe „delete”.

To są dane wyjściowe, które otrzymaliśmy z programu, w którym destruktor czyści i niszczy utworzony obiekt.

Różnica między konstruktorami a destruktorami:

Dziedziczenie C++:

Teraz dowiemy się o dziedziczeniu C++ i jego zakresie.

Dziedziczenie to metoda, dzięki której nowa klasa jest generowana lub dziedziczona z istniejącej klasy. Obecna klasa jest określana jako „klasa bazowa” lub również „klasa nadrzędna”, a nowo tworzona klasa jest określana jako „klasa pochodna”. Kiedy mówimy, że klasa potomna jest dziedziczona z klasy rodzica, oznacza to, że dziecko posiada wszystkie właściwości klasy rodzica.

Dziedziczenie odnosi się do relacji (jest a). Nazywamy każdą relację dziedziczeniem, jeśli między dwiema klasami użyto „is-a”.

Na przykład:

• Papuga to ptak.
• Komputer to maszyna.

Składnia:

W programowaniu C++ używamy lub piszemy Inheritance w następujący sposób:

Tryby dziedziczenia C++:

Dziedziczenie obejmuje 3 tryby dziedziczenia klas:

• Publiczny: W tym trybie, jeśli zadeklarowana jest klasa potomna, to elementy klasy nadrzędnej są dziedziczone przez klasę potomną, tak samo jak w klasie nadrzędnej.
• Zabezpieczony: Ja W tym trybie publiczni członkowie klasy nadrzędnej stają się chronionymi członkami klasy potomnej.
• Prywatny : W tym trybie wszyscy członkowie klasy nadrzędnej stają się prywatnymi w klasie podrzędnej.

Rodzaje dziedziczenia C++:

Oto typy dziedziczenia C++:

1. Pojedyncze dziedziczenie:

Dzięki temu rodzajowi dziedziczenia klasy pochodzą z jednej klasy bazowej.

Składnia:

2. Dziedziczenie wielokrotne:

W tego rodzaju dziedziczeniu klasa może wywodzić się z różnych klas bazowych.

Składnia:

3. Dziedziczenie wielopoziomowe:

Klasa podrzędna wywodzi się z innej klasy podrzędnej w tej formie dziedziczenia.

Składnia:

4. Dziedziczenie hierarchiczne:

W tej metodzie dziedziczenia z jednej klasy bazowej tworzonych jest kilka podklas.

Składnia:

5. Dziedziczenie hybrydowe:

W tego rodzaju dziedziczeniu łączy się wiele dziedziczeń.

Składnia:

Przykład:

Uruchomimy kod, aby zademonstrować koncepcję wielokrotnego dziedziczenia w programowaniu w C++.

Ponieważ zaczęliśmy od standardowej biblioteki wejścia-wyjścia, nadaliśmy nazwę klasy bazowej „Bird” i upubliczniliśmy ją, aby jej składowe były dostępne. Następnie mamy klasę bazową „Gad”, którą również upubliczniliśmy. Następnie mamy „cout”, aby wydrukować wyjście. Następnie stworzyliśmy „pingwina” klasy dziecięcej. w Główny() funkcji zrobiliśmy obiekt klasy pingwin „p1”. Najpierw zostanie wykonana klasa „Ptak”, a następnie klasa „Gad”.

Po wykonaniu kodu w C++ otrzymujemy instrukcje wyjściowe klas bazowych „Ptak” i „Gad”. Oznacza to, że klasa „pingwin” wywodzi się z klas bazowych „ptak” i „gad”, ponieważ pingwin jest zarówno ptakiem, jak i gadem. Może latać i czołgać się. Stąd wielokrotne dziedziczenie dowiodło, że jedna klasa potomna może pochodzić z wielu klas bazowych.

Przykład:

Tutaj uruchomimy program, który pokaże, jak korzystać z wielopoziomowego dziedziczenia.

Nasz program zaczęliśmy od strumieni wejścia-wyjścia. Następnie zadeklarowaliśmy klasę nadrzędną „M”, która jest ustawiona jako publiczna. Nazwaliśmy wyświetlacz() funkcja i polecenie „cout”, aby wyświetlić instrukcję. Następnie utworzyliśmy klasę potomną „N”, która wywodzi się z klasy nadrzędnej „M”. Mamy nową klasę potomną „O” wyprowadzoną z klasy potomnej „N”, a treść obu klas pochodnych jest pusta. Na koniec przywołujemy Główny() funkcja w której musimy zainicjalizować obiekt klasy ‘O’. The wyświetlacz() funkcja obiektu jest wykorzystywana do demonstracji wyniku.

Na tym rysunku mamy wynik klasy „M”, która jest klasą nadrzędną, ponieważ mieliśmy a wyświetlacz() w nim funkcjonować. Tak więc klasa „N” wywodzi się z klasy rodzicielskiej „M”, a klasa „O” z klasy rodzicielskiej „N”, która odnosi się do dziedziczenia wielopoziomowego.

Polimorfizm C++:

Termin „polimorfizm” reprezentuje zbiór dwóch słów „poli” oraz ' morfizm” . Słowo „Poly” reprezentuje „wiele”, a „morfizm” reprezentuje „formy”. Polimorfizm oznacza, że ​​obiekt może zachowywać się różnie w różnych warunkach. Pozwala programiście na ponowne wykorzystanie i rozszerzenie kodu. Ten sam kod działa różnie w zależności od warunku. Aktywacja obiektu może być zastosowana w czasie wykonywania.

Kategorie polimorfizmu:

Polimorfizm występuje głównie na dwa sposoby:

1. Polimorfizm czasu kompilacji
2. Polimorfizm w czasie wykonywania

Wyjaśnijmy.

6. Polimorfizm czasu kompilacji:

W tym czasie wprowadzony program zamienia się w program wykonywalny. Przed wdrożeniem kodu wykrywane są błędy. Są to przede wszystkim dwie kategorie.

• Przeciążenie funkcji
• Przeciążenie operatora

Przyjrzyjmy się, jak wykorzystujemy te dwie kategorie.

7. Przeciążenie funkcji:

Oznacza to, że funkcja może wykonywać różne zadania. Funkcje są znane jako przeciążone, gdy istnieje kilka funkcji o podobnej nazwie, ale odrębnych argumentach.

Po pierwsze, używamy biblioteki oraz standardowej przestrzeni nazw. Następnie zadeklarujemy zdefiniowaną przez użytkownika klasę „Dodaj”. Wewnątrz klasy definiujemy funkcję ADD() z dwoma parametrami jako public. Ponownie zadeklaruj nową funkcję w ciele klasy o tej samej nazwie, ale ta funkcja nie ma parametru. Tutaj inicjujemy trzy ciągi. Pierwsze dwa ciągi mają pewną wartość, a ostatni ciąg służy do łączenia pierwszych dwóch ciągów. Używamy polecenia „cout”, aby wydrukować wynik. Następnie nazywamy Główny() metoda poza klasą. Konstruujemy obiekt wymaganej klasy „Add”. Teraz wywołujemy pierwszą funkcję z dwoma parametrami, a następnie wywołujemy również drugą funkcję. W ostatnim kroku dołączamy instrukcję „return 0”, aby zakończyć program.

Przeciążenie operatora:

Proces definiowania wielu funkcjonalności operatora nazywamy przeciążaniem operatora.

Powyższy przykład zawiera plik nagłówkowy . Następnie korzystaliśmy ze standardowej przestrzeni nazw. Definiujemy klasę „Liczba całkowita”. W tej klasie określamy liczbę całkowitą jako prywatny element klasy. Następnie deklarujemy konstruktor sparametryzowany jako publiczny element członkowski i inicjujemy w nim wartość liczby całkowitej. Definiujemy konstruktora z przeciążającym operatorem prefiksu. Wewnątrz tego konstruktora wykonujemy operację prefiksu. Ponadto tworzymy funkcję wyświetlającą wartość przyrostu za pomocą instrukcji „cout”. Tymczasem przywołujemy Główny() funkcjonować. Tutaj tworzymy dwa obiekty klasy. Pierwszy obiekt przekazuje wartość liczby całkowitej. Następnie użyj instrukcji „cout”, aby wydrukować wiersz „Przed zwiększeniem wartości jest”. Następnie dzwonimy wyświetlacz() funkcja dla pierwszego obiektu. Drugi obiekt używa operatora pre-inkrementacji. Używamy polecenia „cout”, aby wyświetlić wiersz „Po wstępnej inkrementacji wartość wynosi”. Następnie używamy wyświetlacz() funkcja dla drugiego obiektu.

8. Polimorfizm w czasie wykonywania:

Jest to czas, w którym działa kod. Po zastosowaniu kodu można wykryć błędy.

Nadpisywanie funkcji:

Dzieje się tak, gdy klasa pochodna używa podobnej definicji funkcji jak jedna z funkcji składowych klasy bazowej.

W pierwszym wierszu dołączamy bibliotekę do wykonywania operacji wejścia i wyjścia. Ponadto dodajemy standardową przestrzeń nazw. W kolejnym wierszu deklarujemy klasę rodzicielską „Man”. Wewnątrz klasy definiujemy funkcję z dwoma parametrami jako public. Następnie używamy wyrażenia „cout”, aby wyświetlić tekst „Walking”. Poza klasą tworzymy klasę potomną „Animal”, która wywodzi się z klasy nadrzędnej. Tutaj tworzymy funkcję o nazwie podobnej do tej, która była wcześniej zadeklarowana w klasie nadrzędnej. Następnie użyj wyrażenia „cout”, aby pokazać tekst „Jedzenie”. Używamy Główny() funkcjonować. W międzyczasie tworzymy obiekt klasy „m”. Następnie wywołujemy funkcję klasy nadrzędnej oraz funkcję klasy potomnej. Użyj polecenia „zwróć 0”.

Ciągi C++:

Teraz dowiemy się, jak zadeklarować i zainicjować String w C++. String służy do przechowywania grupy znaków w programie. Przechowuje w programie wartości alfabetyczne, cyfry i symbole specjalnego typu. Zarezerwował znaki jako tablicę w programie C++. Tablice służą do rezerwowania kolekcji lub kombinacji znaków w programowaniu w języku C++. Do zakończenia tablicy używany jest specjalny symbol znany jako znak null. Jest reprezentowany przez sekwencję ucieczki (\0) i służy do określenia końca ciągu.

Pobierz ciąg za pomocą polecenia „cin”:

Służy do wprowadzania zmiennej łańcuchowej bez spacji. W podanym przypadku implementujemy program w C++, który pobiera nazwę użytkownika za pomocą polecenia „cin”.

W pierwszym kroku korzystamy z biblioteki . Tymczasem uwzględniliśmy standardową przestrzeń nazw. Następnie deklarujemy Główny() funkcjonować. Inicjujemy łańcuch znaków w ciele Główny() funkcjonować. Następnie używamy wyrażenia „cout”, aby wydrukować „Wprowadź swoje imię”. Używamy polecenia „cin”, aby zapytać użytkownika o ciąg znaków. Polecenie „cout” jest stosowane do wydrukowania nazwy, która zostałaby napisana przez użytkownika. Instrukcja return 0 jest dodawana w celu zakończenia programu.

Użytkownik wprowadza imię „Ahmed Chaudry”. Ale otrzymujemy tylko 'Ahmed' jako dane wyjściowe, a nie kompletne 'Ahmed Chaudry', ponieważ polecenie 'cin' nie może przechowywać ciągu z spacją. Przechowuje tylko wartość przed spacją.

Pobierz ciąg za pomocą funkcji cin.get():

The Dostawać() funkcja polecenia cin służy do pobrania z klawiatury ciągu znaków, który może zawierać spacje.

Powyższy przykład zawiera bibliotekę do wykonywania operacji wejścia i wyjścia. Następnie użyliśmy standardowej przestrzeni nazw. The Główny() wywoływana jest funkcja. Następnie inicjujemy ciąg o nazwie „s”. W kolejnym kroku komenda „cout” służy do wyświetlenia instrukcji „Wprowadź ciąg”. The cin.get() jest stosowany w celu pobrania ciągu od użytkownika. Używając cin.get() funkcji przekazujemy wartość ciągu i określamy rozmiar ciągu jako parametr. Polecenie „cout” jest ponownie wykorzystywane do wyświetlania wyników programu. Na koniec dodajemy zwrot 0.

Użytkownik wprowadza ciąg „Nazywam się Ali”. Jako wynik otrzymujemy kompletny ciąg „Nazywam się Ali”, ponieważ funkcja cin.get() akceptuje ciągi zawierające spacje.

Korzystanie z 2D (dwuwymiarowej) tablicy ciągów:

W tym przypadku pobieramy dane wejściowe (nazwy trzech miast) od użytkownika, wykorzystując tablicę ciągów 2D.

Najpierw integrujemy plik nagłówkowy i standardową przestrzeń nazw. Wzywamy Główny() funkcjonować. Następnie inicjujemy dwuwymiarową tablicę znaków z trzema wierszami i piętnastoma kolumnami. W następnym kroku pętla for jest używana do zliczania zmiennej „i”, aby iterować po wymaganym ciągu do momentu zidentyfikowania znaku null. Wewnątrz treści pętli „for” używamy polecenia „cout”, aby wyświetlić wiersz „Wprowadź nazwę miasta”. Następnie użyj wyrażenia „cin”, aby uzyskać nazwę miasta. Ponownie używamy kolejnej pętli „for” i instrukcji „cout”, aby wyświetlić nazwy miast w sekwencji, aż pętla się zakończy. Następnie używane jest polecenie „zwróć 0”.

Tutaj użytkownik wpisuje nazwę trzech różnych miast. Program używa indeksu wiersza, aby uzyskać trzy wartości ciągu. Każda wartość jest zachowywana w osobnym wierszu. Pierwszy ciąg jest przechowywany w pierwszym wierszu i tak dalej. Każda wartość ciągu jest wyświetlana w ten sam sposób przy użyciu indeksu wiersza.

Biblioteka standardowa C++:

Biblioteka C++ to klaster lub grupowanie wielu funkcji, klas, stałych i wszystkich powiązanych elementów zawartych w prawie jednym właściwym zestawie, zawsze definiującym i deklarującym standardowe pliki nagłówkowe. Ich implementacja obejmuje dwa nowe pliki nagłówkowe, które nie są wymagane przez standard C++ o nazwach i . Istnieje długa lista obowiązkowych plików nagłówkowych, która zależy od wymagań kompilatora. Pliki nagłówkowe zawierają listę nagłówków, która zawiera całą zawartość Biblioteki Standardowej C++, łącznie z określonymi plikami nagłówkowymi dla Szablonu Biblioteki Stoiska (STL).

Biblioteka Standardowa eliminuje potrzebę przepisywania instrukcji podczas programowania. Zawiera wiele bibliotek, które przechowują kod dla wielu funkcji. Aby dobrze wykorzystać te biblioteki, należy je połączyć za pomocą plików nagłówkowych. Kiedy importujemy bibliotekę wejściową lub wyjściową, oznacza to, że importujemy cały kod, który był przechowywany w tej bibliotece i w ten sposób możemy również korzystać z zawartych w niej funkcji, ukrywając cały podstawowy kod, który może nie być potrzebny Widzieć.

Biblioteka standardowa C++ obsługuje następujące dwa typy:

• Hostowana implementacja, która udostępnia wszystkie niezbędne pliki nagłówkowe biblioteki standardowej opisane w standardzie ISO C++.
• Samodzielna implementacja, która wymaga tylko części plików nagłówkowych ze standardowej biblioteki. Odpowiedni podzbiór to:

Kilka plików nagłówkowych zostało potępionych od czasu pojawienia się ostatniego 11 C++: Są to , i .

Różnice między implementacjami hostowanymi i wolnostojącymi są przedstawione poniżej:

• W implementacji hostowanej musimy użyć funkcji globalnej, która jest funkcją główną. W wolnostojącej implementacji użytkownik może samodzielnie deklarować i definiować funkcje początkowe i końcowe.
• Implementacja hostingu ma jeden wątek obowiązkowo uruchomiony w czasie dopasowywania. Natomiast w implementacji wolnostojącej to realizatorzy sami zdecydują, czy potrzebują w swojej bibliotece obsługi współbieżnego wątku.

Rodzaje:

Zarówno wersja wolnostojąca, jak i hostowana są obsługiwane przez C++. Pliki nagłówkowe dzielą się na dwa:

• Części Iostream
• Części C++ STL (biblioteka standardowa)

Ilekroć piszemy program do wykonania w C++, zawsze wywołujemy funkcje, które są już zaimplementowane w STL. Te znane funkcje pobierają dane wejściowe i wyświetlają dane wyjściowe przy użyciu zidentyfikowanych operatorów z wydajnością.

Biorąc pod uwagę historię, STL początkowo nazywano Standardową Biblioteką Szablonów. Następnie części biblioteki STL zostały następnie ustandaryzowane w Bibliotece Standardowej C++, która jest używana obecnie. Należą do nich biblioteka uruchomieniowa ISO C++ i kilka fragmentów z biblioteki Boost wraz z kilkoma innymi ważnymi funkcjami. Czasami STL oznacza kontenery lub częściej algorytmy biblioteki standardowej C++. Teraz ta biblioteka STL lub standardowa biblioteka szablonów mówi całkowicie o znanej bibliotece standardowej C++.

Przestrzeń nazw std i pliki nagłówkowe:

Wszystkie deklaracje funkcji lub zmiennych są wykonywane w standardowej bibliotece za pomocą plików nagłówkowych, które są między nimi równomiernie rozmieszczone. Deklaracja nie miałaby miejsca, chyba że nie dołączysz plików nagłówkowych.

Załóżmy, że ktoś używa list i ciągów znaków, musi dodać następujące pliki nagłówkowe:

Te nawiasy kątowe „<>” oznaczają, że należy wyszukać ten konkretny plik nagłówkowy w definiowanym i dołączanym katalogu. Można również dodać rozszerzenie „.h” do tej biblioteki, co jest wykonywane w razie potrzeby lub potrzeby. Jeśli wykluczymy bibliotekę „.h”, potrzebujemy dodać „c” tuż przed początkiem nazwy pliku, jako wskazówkę, że ten plik nagłówkowy należy do biblioteki C. Na przykład możesz pisać (#include lub #include ).

Mówiąc o przestrzeni nazw, cała standardowa biblioteka C++ znajduje się w przestrzeni nazw oznaczonej jako std. To jest powód, dla którego wystandaryzowane nazwy bibliotek muszą być kompetentnie zdefiniowane przez użytkowników. Na przykład:

Wektory C++:

Istnieje wiele sposobów przechowywania danych lub wartości w C++. Ale na razie szukamy najłatwiejszego i najbardziej elastycznego sposobu przechowywania wartości podczas pisania programów w języku C++. Tak więc wektory to kontenery, które są odpowiednio zsekwencjonowane we wzorze serii, których rozmiar zmienia się w momencie wykonania w zależności od wstawiania i odejmowania elementów. Oznacza to, że programista mógł zmienić rozmiar wektora zgodnie ze swoim życzeniem podczas wykonywania programu. Przypominają one tablice w taki sposób, że mają również komunikowalne miejsca do przechowywania zawartych w nich elementów. Aby sprawdzić liczbę wartości lub elementów obecnych wewnątrz wektorów, musimy użyć „ std::liczba” funkcjonować. Wektory są zawarte w Standardowej Bibliotece Szablonów C++, więc ma określony plik nagłówkowy, który należy najpierw dołączyć, czyli:

Deklaracja:

Poniżej przedstawiono deklarację wektora.

Tutaj wektor jest użytym słowem kluczowym, DT pokazuje typ danych wektora, który można zastąpić int, float, char lub dowolnym innym powiązanym typem danych. Powyższą deklarację można przepisać jako:

Rozmiar wektora nie jest określony, ponieważ podczas wykonywania może się on zwiększyć lub zmniejszyć.

Inicjalizacja wektorów:

W C++ istnieje więcej niż jeden sposób inicjalizacji wektorów.

Technika numer 1:

W tej procedurze bezpośrednio przypisujemy wartości obu wektorom. Wartości przypisane do obu są dokładnie podobne.

Technika numer 2:

W tym procesie inicjalizacji 3 dyktuje rozmiar wektora, a 15 to dane lub wartości, które zostały w nim zapisane. Tworzony jest wektor typu danych „int” o podanym rozmiarze 3 przechowującym wartość 15, co oznacza, że ​​wektor „v3” przechowuje:

Główne operacje:

Główne operacje, które zamierzamy zaimplementować na wektorach wewnątrz klasy vector to:

• Dodawanie wartości
• Dostęp do wartości
• Zmiana wartości
• Usuwanie wartości

Dodawanie i usuwanie:

Dodawanie i usuwanie elementów wewnątrz wektora odbywa się na bieżąco. W większości przypadków elementy są wstawiane na końcu kontenerów wektorowych, ale można również dodać wartości w żądanym miejscu, co ostatecznie przesunie inne elementy do ich nowych lokalizacji. Natomiast przy usuwaniu, gdy wartości zostaną usunięte z ostatniej pozycji, automatycznie zmniejszy się rozmiar kontenera. Ale gdy wartości wewnątrz kontenera są losowo usuwane z określonej lokalizacji, nowe lokalizacje są automatycznie przypisywane do innych wartości.

Używane funkcje:

Aby zmienić lub zmienić wartości przechowywane w wektorze, istnieją pewne predefiniowane funkcje znane jako modyfikatory. Są to:

• Insert(): Służy do dodawania wartości wewnątrz kontenera wektorów w określonej lokalizacji.
• Erase(): Służy do usuwania lub usuwania wartości wewnątrz kontenera wektorów w określonej lokalizacji.
• Swap(): Służy do wymiany wartości wewnątrz kontenera wektorowego, który należy do tego samego typu danych.
• Assign(): Służy do alokacji nowej wartości do poprzednio zapisanej wartości wewnątrz kontenera wektorów.
• Begin(): Służy do zwracania iteratora wewnątrz pętli, który odnosi się do pierwszej wartości wektora wewnątrz pierwszego elementu.
• Clear(): Służy do usuwania wszystkich wartości przechowywanych w kontenerze wektorowym.
• Push_back(): Służy do dodawania wartości na końcu kontenera wektorów.
• Pop_back(): Służy do usuwania wartości na końcu kontenera wektorów.

Przykład:

W tym przykładzie wzdłuż wektorów używane są modyfikatory.

Najpierw dołączamy pliki nagłówkowe i . Następnie przestrzeń nazw std jest integrowana, aby dodać wszystkie klasy jednocześnie. Aby napisać logikę całego programu, wywołujemy funkcję main(), w której inicjowany jest wektor o nazwie „cyfry”. Przypisanie tego wektora odbywa się w kolejnym kroku, gdzie 'cyfry' mają wartość 6 i 24, co oznacza, że ​​wewnątrz kontenera wektorów przechowywanych jest 6 elementów, każdy o wartości 24. Wartości te są następnie wyświetlane za pomocą funkcji 'cout ' Komenda. Pętla „for” jest wykorzystywana przez funkcję modyfikującą push_back() do dodawania elementów wewnątrz kontenera. Teraz do cyfr na końcu dodawana jest wartość 3. Inicjujemy zmienną „x” do przechowywania zapisu rozmiaru kontenera wektorów. Teraz wyświetlana jest wartość ostatniego elementu, a pop_back() funkcja usunęłaby liczbę „3” przechowywaną w kontenerze. Aby wyświetlić wszystkie elementy, ponownie używamy pętli „for” z wstawić() modyfikator, który wstawi wartości. Tutaj 4 zostanie wstawione na początku kontenera wektorów i wyświetlone na ekranie. The jasne() modyfikator następnie wyczyści lub usunie wszystkie wartości przechowywane w kontenerze. Rozmiar wektora jest następnie pokazywany po zakończeniu czyszczenia.

Dane wyjściowe pokazano poniżej.

Dane wejściowe plików C++:

Plik to zbiór powiązanych ze sobą danych. W C++ plik jest sekwencją bajtów zebranych razem w porządku chronologicznym. Większość plików znajduje się na dysku. Ale w plikach znajdują się również urządzenia sprzętowe, takie jak taśmy magnetyczne, drukarki i linie komunikacyjne.

Dane wejściowe i wyjściowe w plikach charakteryzują trzy główne klasy:

• Klasa „istream” służy do pobierania danych wejściowych.
• Do wyświetlania danych wyjściowych wykorzystywana jest klasa „ostream”.
• W przypadku danych wejściowych i wyjściowych użyj klasy „iostream”.

Pliki są obsługiwane jako strumienie w C++. Kiedy pobieramy dane wejściowe i wyjściowe w pliku lub z pliku, używane są następujące klasy:

• Zagraniczni: Jest to klasa strumienia używana do zapisu do pliku.
• Jeśli strumień: Jest to klasa strumienia używana do odczytywania treści z pliku.
• Strumień: Jest to klasa strumienia, która jest używana zarówno do odczytu, jak i zapisu w pliku lub z pliku.

Klasy „istream” i „ostream” są przodkami wszystkich klas wymienionych powyżej. Strumienie plików są tak łatwe w użyciu, jak polecenia „cin” i „cout”, z tą różnicą, że kojarzą te strumienie plików z innymi plikami. Zobaczmy przykład, aby pokrótce przestudiować klasę „fstream”:

Przykład:

W tym przypadku zapisujemy dane do pliku.

W pierwszym kroku integrujemy strumień wejściowy i wyjściowy. Następnie dodawany jest plik nagłówkowy , ponieważ zamierzamy zapisywać i odczytywać dane z pliku. Następnie klasy są wywoływane za pomocą przestrzeni nazw. The Główny() funkcja jest wywoływana dla ciała programu, gdzie używany jest „ofstream”, który zapisuje dane do pliku, plik jest tworzony jako New_File. W następnym kroku otwieramy plik tekstowy o nazwie „przykład” za pomocą otwarty( ) metoda. Do pliku wpisujemy tekst za pomocą nawiasów kątowych. Każdy plik jest przeznaczony do zamknięcia po jego rozwiązaniu. Dlatego plik jest zamykany za pomocą blisko() funkcjonować.

Plik „przykład” jest otwierany z komputera osobistego, a tekst zapisany w pliku jest odciskany na tym pliku tekstowym, jak pokazano powyżej.

Otwieranie pliku:

Gdy plik jest otwarty, jest reprezentowany przez strumień. Dla pliku tworzony jest obiekt, tak jak w poprzednim przykładzie utworzono New_File. Wszystkie operacje wejścia i wyjścia, które zostały wykonane w strumieniu, są automatycznie stosowane do samego pliku. Do otwierania pliku funkcja open() jest używana jako:

Tutaj tryb jest nieobowiązkowy.

Zamknięcie pliku:

Po zakończeniu wszystkich operacji wejścia i wyjścia, musimy zamknąć plik, który został otwarty do edycji. Mamy obowiązek zatrudnić blisko() funkcjonować w tej sytuacji.

Po wykonaniu tej czynności plik staje się niedostępny. Jeśli w jakichkolwiek okolicznościach obiekt zostanie zniszczony, nawet będąc połączonym z plikiem, destruktor spontanicznie wywoła funkcję close().

Pliki tekstowe:

Pliki tekstowe służą do przechowywania tekstu. W związku z tym, jeśli tekst zostanie wprowadzony lub wyświetlony, będzie zawierał pewne zmiany formatowania. Operacja pisania w pliku tekstowym jest taka sama, jak wykonujemy polecenie „cout”.

Przykład:

W tym scenariuszu zapisujemy dane w pliku tekstowym, który został już utworzony na poprzedniej ilustracji.

Tutaj zapisujemy dane w pliku o nazwie „przykład” za pomocą funkcji New_File(). Otwieramy plik „przykład” za pomocą otwarty() metoda. „Oficja” służy do dodawania danych do pliku. Po wykonaniu wszystkich prac wewnątrz pliku, wymagany plik jest zamykany za pomocą blisko() funkcjonować. Jeśli plik nie otwiera się, wyświetlany jest komunikat o błędzie „Plik nie jest obsługiwany, błąd podczas ładowania pliku”.

Plik zostanie otwarty, a tekst zostanie wyświetlony na konsoli.

Czytanie pliku tekstowego:

Odczytanie pliku pokazano na poniższym przykładzie.

Przykład:

„ifstream” służy do odczytywania danych przechowywanych w pliku.

Przykład zawiera główne pliki nagłówkowe na początku. Następnie użyj „ifstream” wewnątrz Główny() funkcjonować. Za pomocą „ifstream” odczytamy dane z pliku „New_File” pokazując tekst przechowywany w „przykładowym” pliku tekstowym. Zatrudniamy otwarty() metoda otwierania pliku. Następnie wykorzystamy pętlę „while”. Po odczytaniu danych z „przykładowego” pliku tekstowego, blisko() funkcja służy do zamykania wymaganego pliku. Jeśli w systemie nie ma konkretnego pliku, to otrzymujemy komunikat „Nie można otworzyć pliku”.

Wszystkie informacje przechowywane w pliku tekstowym są wyświetlane na ekranie, jak pokazano.

Wniosek

W powyższym przewodniku szczegółowo poznaliśmy język C++. Wraz z przykładami każdy temat jest prezentowany i wyjaśniany, a każde działanie jest dopracowywane.