Operator jednoargumentowy w C++

Operator Jednoargumentowy W C



W C++ operator jednoargumentowy to operator, który działa tylko na jednym operandze. Operatory jednoargumentowe odgrywają kluczową rolę w C++, umożliwiając manipulowanie wartością związaną z pojedynczą zmienną lub wyrażeniem. Tych wszechstronnych operatorów można używać w różnych kontekstach, takich jak zwiększanie lub zmniejszanie zmiennej, zmiana znaku wartości liczbowej lub wykonywanie logicznej negacji. W tym artykule omówiono operatory jednoargumentowe w języku C++, omawiając ich typy i zastosowania oraz podając wiele przykładów dla lepszego zrozumienia.

C++ obsługuje kilka operatorów jednoargumentowych, z których każdy służy unikalnemu celowi w manipulowaniu zmiennymi. Zacznijmy od operatorów inkrementacji i dekrementacji, które są powszechnie używane w pętlach i różnych algorytmach.

Przykład 1: Operatory zwiększania (++) i zmniejszania (–).

Jednoargumentowe operatory inkrementacji (++) i dekrementacji (–) to podstawowe narzędzia w języku C++ służące do modyfikowania wartości zmiennej poprzez odpowiednio zwiększenie lub zmniejszenie jej o 1. Operator inkrementacji (++) dodaje 1 do wartości zmiennej, natomiast operator dekrementacji (–) odejmuje 1. Operatory te można stosować do zmiennych całkowitych, zmiennoprzecinkowych i wskaźnikowych, zapewniając elastyczność w ich użyciu.







Przyjrzyjmy się tym operatorom na praktycznym przykładzie:



#include
za pomocą przestrzeń nazw st ;

wew główny ( )
{

wew lada = 0 ;

// Operator inkrementacji
cout << 'Wartość początkowa: ' << lada << koniec ;

lada ++ ;
cout << „Wartość po zwiększeniu:” << lada << koniec ;

// Operator zmniejszania
lada -- ;
cout << „Wartość po zmniejszeniu:” << lada << koniec ;

powrót 0 ;
}

Ten prosty program w języku C++ zawiera niezbędną bibliotekę strumieni wejścia/wyjścia z opcją „#include ”. W ramach funkcji „main()” tworzymy zmienną całkowitą zwaną „licznik” i przypisujemy jej wartość początkową 0. Za pomocą instrukcji „cout” wypisujemy na konsolę początkową wartość „licznika”, podając punkt odniesienia dla naszej demonstracji. Idąc dalej, operator inkrementacji (licznik++) służy do podniesienia wartości zmiennej „licznik” o 1.



Po tej operacji zaktualizowana wartość „counter” jest wyświetlana za pomocą kolejnej instrukcji „cout”. Następnie za pomocą operatora zmniejszania (licznik-) zmniejszamy wartość „licznika” o 1. Wynik jest następnie wyświetlany na konsoli. Ostatecznie program kończy się „powrotem 0”; instrukcja wskazująca pomyślne wykonanie.





Obraz wyjściowy pokazuje wartość początkową, wartość po zwiększeniu i wartość zmniejszoną.



Przykład 2: Operatory dodatnie (+) i ujemne (-).

Chociaż dodatni operator jednoargumentowy jest rzadko używany, operator ujemny ma fundamentalne znaczenie przy zmianie znaku zmiennej.

#include
Za pomocą przestrzeń nazw st ;

wew główny ( ) {
wew Wartość dodatnia = 10 ;
wew ujemna wartość = - Wartość dodatnia ;

cout << „Wartość dodatnia:” << Wartość dodatnia << koniec ;
cout << 'Ujemna wartość: ' << ujemna wartość << koniec ;

powrót 0 ;
}

Inicjujemy dwie zmienne całkowite dla tego przykładowego kodu, którymi są „positiveValue” i „negativeValue”. Do „positiveValue” przypisuje się wartość 10. Następnie deklarujemy „negativeValue” i przypisujemy jej negację „positiveValue” za pomocą jednoargumentowego operatora minus. Operator ten skutecznie zmienia znak oryginalnej wartości. Następnie używamy instrukcji „cout”, aby wyświetlić na konsoli zarówno dodatni, jak i ujemny wynik. Na koniec program zwraca 0, co oznacza pomyślne zakończenie funkcji głównej.

Po wykonaniu program ten wyświetla wartości dodatnie i ujemne.

Przykład 3: Operator logiczny NOT (!).

Operator jednoargumentowy w C++, oznaczony znakiem „!” symbol, nazywany jest operatorem logicznym NOT. Ma na celu odwrócenie wartości logicznej danego wyrażenia. Działa na pojedynczym operandie, który jest zazwyczaj wyrażeniem logicznym lub warunkiem. Logiczna operacja NOT daje wynik „prawdziwy”, gdy operand jest „fałszywy”, i daje wynik „fałszywy”, gdy operand jest „prawdą”.

Oto prosty przykład ilustrujący użycie operatora logicznego NOT:

#include
za pomocą przestrzeń nazw st ;

wew główny ( ) {
bool jest prawdziwy = PRAWDA ;
bool to fałsz = FAŁSZ ;

bool wynikNieprawda = ! jest prawdziwy ;
bool wynikNotFalse = ! to fałsz ;

cout << 'Oryginalna wartość: ' << jest prawdziwy << ', Po NIE: ' << wynikNieprawda << koniec ;
cout << 'Oryginalna wartość: ' << to fałsz << ', Po NIE: ' << wynikNotFalse << koniec ;

powrót 0 ;
}

W tym przykładzie deklarujemy dwie zmienne logiczne: „isTrue” i „isFalse”. Następnie stosujemy operator logiczny NOT do każdej zmiennej, przechowując wyniki odpowiednio w „resultNotTrue” i „resultNotFalse”. Następnie program wypisuje oryginalne wartości i wyniki logicznej operacji NOT dla obu zmiennych.

Po uruchomieniu tego programu zauważymy, że operator logiczny NOT odwraca wartość logiczną „isTrue” (początkowo ustawioną na true), czyniąc ją fałszywą. Podobnie odwraca wartość logiczną „isFalse” (pierwotnie fałszywą), otrzymując wartość true.

Dane wyjściowe wyraźnie ilustrują odwrócenie wartości logicznych uzyskanych za pomocą operatora logicznego NOT.

Przykład 4: Operator bitowy NOT (~).

Bitowy operator NOT (~) w C++ jest operatorem jednoargumentowym, który wykonuje bitową negację każdego bitu swojego operandu. Działa z podstawowymi typami danych, w szczególności z integralnymi, takimi jak liczby całkowite. Wynik osiąga się poprzez odwrócenie każdego pojedynczego bitu w operandzie, konwersję 0 na 1 i 1 na 0.

Aby zilustrować jego użycie, rozważ następujący fragment kodu:

#include
za pomocą przestrzeń nazw st ;

wew główny ( ) {
wew oryginalna wartość = 5 ;

wew wynikBitwiseNot = ~oryginalna wartość ;

cout << 'Oryginalna wartość: ' << oryginalna wartość << ', Po bitowym NIE: ' << wynikBitwiseNot << koniec ;

powrót 0 ;
}

W tym przykładzie deklarujemy zmienną całkowitą „originalValue” o wartości „5”. Następnie używamy bitowego operatora NOT (~) na tej zmiennej. Wynik tej zmiennej jest przechowywany w „resultBitwiseNot”. Następnie program wypisuje oryginalną wartość i wynik po bitowej operacji NOT, korzystając z instrukcji „cout”.

Kiedy uruchomimy ten program, zobaczymy, że bitowy operator NOT odwraca każdy bit binarnej reprezentacji „oryginalnej Wartości”, tworząc nową wartość.

Przykład 5: Operatory adresu i pośrednictwa

Operator adresu, oznaczony symbolem „&”, służy do odczytania miejsca w pamięci zmiennej. Zwraca wskaźnik do zmiennej, co umożliwia pośredni dostęp do jej wartości. Operator pośredni lub dereferencji (*) uzyskuje wartość przechowywaną w lokalizacji pamięci określonej przez wskaźnik. Umożliwia pośrednią pracę z rzeczywistymi danymi za pomocą wskaźnika.

Wyjaśnijmy to pojęcie na przykładzie:

#include
za pomocą przestrzeń nazw st ;

wew główny ( ) {
wew wartość = 99 ;

cout << 'Oryginalna wartość: ' << wartość << koniec ;

wew * pt = & wartość ;
cout << „Adres pamięci:” << pt << koniec ;

wew pobrana wartość = * pt ;
cout << „Odzyskana wartość:” << pobrana wartość << koniec ;

powrót 0 ;
}

Ten kod ilustruje wykorzystanie operatorów adresowych i pośrednich. Najpierw zmienna całkowita o nazwie „wartość” jest inicjowana wartością 99. Oryginalna wartość „wartość” jest następnie wysyłana do konsoli. Następnie deklarowana jest zmienna wskaźnikowa „ptr”, a operator adresu (&) jest używany do przypisania adresu pamięci „value” do „ptr”. Następnie program wyprowadza ten adres pamięci, pokazując podstawowe działanie operatora „adresu”.

Następnie deklarowana jest nowa zmienna całkowita o nazwie „retrievedValue” i za pomocą operatora pośredniego (*) pobierana jest wartość przechowywana pod adresem pamięci wskazanym przez „ptr”. Pobrana wartość jest następnie wysyłana do konsoli.

Wniosek

W tym artykule szczegółowo omówiono operatory jednoargumentowe w języku C++. Zaczęliśmy od podzielenia operatorów jednoargumentowych na różne typy, w tym arytmetyczne, logiczne, bitowe oraz te związane z adresem i pośredniością. Podano przykłady rzeczywistych sytuacji, aby zademonstrować przydatne zastosowanie tych operatorów. Operatory te odgrywają kluczową rolę w programowaniu w C++, co pozwala programistom wydajnie pracować ze wskaźnikami i zarządzać pamięcią.