przypisywanie wartości, operacje arytmetyczne, operatory przyrostów

Mimo iż wcześniej już trochę używałem operatorów, założyłem, że użytkownik zrozumie ich znaczeni z kontekstu przykładu.

Przypisaniem wartości do zmiennej to tak naprawdę nadanie jej wartości, przypisujemy wartości po prawej stronie operatora „=” do zmiennej po lewej stronie. Przykład poniżej przypisuje wartość 42 do zmiennej całkowitej 'x’:

int x=42;

Wartość dla zmiennej można przypisywać, podczas jej deklaracji lub podczas działania programu:

int x;
x=42;

Jak już wcześniej wspominałem, kod realizowany jest od góry w dół, dlatego podczas przypisywania wartości, zmienna przyjmuje jej ostatnie przypisanie:

                int x;
                x = 42;
                x = 32;
                x = 5;
                Console.WriteLine(x); //Wyświetli 5
                x = 2 + x;
                Console.WriteLine(x); //Wyświetli 7

Operatory są to symbole, które wykonują matematyczne lub logiczne manipulacje. C# wspiera wymienione niżej podstawowe operacje arytmetyczne:

Przykład użycia:

            int x = 9;
            int y = 3;

            Console.WriteLine(x + y); //wyświetli 12
            Console.WriteLine(x - y); //wyświetli 6
            Console.WriteLine(x * y); //wyświetli 27
            Console.WriteLine(x / y); //wyświetli 3
            Console.WriteLine(x % y); //wyświetli 0 (ponieważ reszta z dzielenie 9 przez 3 to zero)

Operacje arytmetyczne możemy przeprowadzać, deklarując zmienne podczas przypisywania jej wartości, lub modyfikować jej wartość w dalszej części programu. Zmiany i manipulację zmienną mogą doprowadzić do zmiany jej rodzaju, dzielenie dwóch liczb typu całkowitego (int) może doprowadzić do powstania zmiennej typu zmiennoprzecinkowego (double), jeśli przypiszemy otrzymaną w taki sposób wartość do zmiennej typu całkowitego, zostanie ona zaokrąglona. Dzielenie dwóch liczb niekoniecznie zwróci wartość zmiennoprzecinkowego, jeśli obie liczby będą typu całkowitego, operacja zwróci wartość całkowitą:

            double x = 9 / 4; //Wyświetli 2, ponieważ oba elementy są typu całkowitego
                              //aby to naprawić, należy utworzyć wartość rzeczywistą, 
                              //jedną z poniższych metod
            Console.WriteLine(x);
            double y = 8.0 / 3.0;
            Console.WriteLine(y); //Wyświetli 2,66666666666667
            double z = Convert.ToDouble(8) / Convert.ToDouble(3); //Wyświetli 2,66666666666667
            Console.WriteLine(z);
            double a = 8 / 3.0; //Wyświetli 2,66666666666667
            Console.WriteLine(a);
            double c = 8d / 3; //Wyświetli 2,66666666666667
            Console.WriteLine(c);

Oczywiście dzielenie przez zero doprowadzi do wyświetlenia błędu. Wartość do zmiennej możemy przypisywać, określając jej wartość na początku lub w trakcie działania programu, łącząc inne zmienne.

            double x;
            double y = 8.0 / 3.0;
            x = y * 10;
            Console.WriteLine("x= " + x);//Wyświetli x= 26,6666666666667
            x = 5;
            Console.WriteLine("x= " + x);//Wyświetli x= 5
            double a = x * y;
            Console.WriteLine("a= " + a);//Wyświetli a= 13,3333333333333

Na szczególną uwagę, zasługuje tutaj moduł, z którym użytkownik mógł nie mieć styczności, jego działanie wygląda następująco:

a % b  =  a – (b * Fix(a / b))  gdzie Fix oznacza zaokrąglenie w dół.

56 % 127 =  56-(127*Fix(56/127))=56-(127* Fix(0,4409448819)) = 56-(127*0)= 56

Operację arytmetyczną dodawania, można przeprowadzać również na łańcuchach znakowych i na samych znakach, jeśli jedna ze zmiennych jest typu łańcucha znaków, wtedy wartość zostanie zwrócona właśnie w tym rodzaju.

            Console.WriteLine("5" + "5"); //Wyświetli 55
            Console.WriteLine(5.0 + "5"); //Wyświetli 55
            Console.WriteLine(5+ "5"+ 'X'); //Wyświetli 55X
            Console.WriteLine(5 + 'X'); //Wyświetli 93, ponieważ indeks litery X w tabeli Unicode wynosi 88

Kolejność wykonywania operacji jest taka jak w matematyce, najpierw wykonujemy mnożenie i dzielenie, a następnie dodawanie i odejmowania, chyba że we wzorze pojawią się nawiasy:

            int a = 10;
            int b = 4;
            int c = 3;
            Console.WriteLine(3 + 4 * 10); //Wyświetli 43
            Console.WriteLine((3 + 4) * 10); //Wyświetli 70

Aby wykonywać inne matematyczne operacje jak potęgowanie, pierwiastkowanie, logarytmowanie itp. Należy skorzystać z klasy Math zawartej w .Net Framework, która zawiera takie metody:

Zawiera ona również stałe zmienne, które możemy wywołać, takie jak liczba PI lub liczba Eulera.

            double a = 10.0;
            double b = -4.0;

            Console.WriteLine(Math.Abs(a*b)); //Wyświetli 40 (wartość bezwzględną, |10*(-1)|.
            Console.WriteLine(Math.Ceiling(a /b)); //-2 Zwraca najmniejszą wartość całkowitą, 
            //która jest większa lub równa określonej liczby dziesiętnej.
            Console.WriteLine(Math.Floor(a / b)); //-3 Zwraca największą liczbę całkowitą mniejszą niż 
            //określona liczba dziesiętna.
            Console.WriteLine(Math.Exp(a + b)); //Zwraca e podniesione do określonej potęgi.
            Console.WriteLine(Math.Log(a + b)); //Zwraca (z podstawą e) logarytm określonej liczby.
            Console.WriteLine(Math.Pow(a,b)); //Zwraca określoną liczbę podniesioną do wskazanej potęgi.
            Console.WriteLine(Math.Round(a / b,3)); //ZZaokrągla liczbę do określonej liczby cyfr ułamkowych 
            //wartości dziesiętnej.
            Console.WriteLine(Math.PI*2); //Zwraca liczbę PI pomnożoną przez dwa.
            Console.WriteLine(Math.E+3); //Zwraca sumę liczby Eulera i trzech.

Kolejnym elementem wykorzystywanym w pętlach i warunkach są operatory przypisania zespołowego, które wykonują operację i przypisanie w jednej deklaracji.

            int x=10;
            x += 2; // x=x+2
            Console.WriteLine(x);//Wyświetli 12 ponieważ 12=10+2
            x -= 6; // x=x-6
            Console.WriteLine(x);//Wyświetli 6 ponieważ 6=12-6

Taka sama składnia skrótowa dotyczy operatorów mnożenia, podziału i modułu.

            int x=10;
            x *= 2; // x=x * 2
            Console.WriteLine(x);//Wyświetli 20 ponieważ 20=10 * 2
            x /= 4; // x=x / 4
            Console.WriteLine(x);//Wyświetli 5 ponieważ 5=20 / 4
            x %= 3;// x=x % 3
            Console.WriteLine(x);//Wyświetli 2 ponieważ 2=5 % 3

Operatory przyrostu, wykorzystywane są do zwiększenia wartości całkowitej (integer) o jeden, jest powszechnie używanym operatorem w C#.

x++; x=x+1

Operator przyrostu ma dwie formy, prefix i postfix

++x; //prefix
x++; //postfix

Prefix zwiększa wartość zmiennej a następnie przechodzi do wyrażenia

Postfix ocenia wyrażenie, a następnie wykonuje przyrost

            int x = 3;
            int y = ++x; //x będzie równe 4, y będzie równe 4

            int x = 3;
            int y = x++; //x będzie równe 4, y będzie równe 3

Istnieje również Operatora redukcji, działa w taki sam sposób:

            int x = 3;
            int y = x--; //x będzie równe 2, y będzie równe 3

            int x = 3;
            int y = --x; //x będzie równe 2, y będzie równe 2

Elementy te zazwyczaj używa się do zwiększenia lub zmniejszenia wartości podczas wykonywania pętli.

Istnieją również specjalne warunki o których warto wiedzieć. Operator ?? sprawdza on czy wartość jest null (pusta) jeśli tak, wtedy przypisze do niej wartość domyślną.

            string s=null;
            int? o = null;
            int y = o ?? 0;
            Console.WriteLine(s ?? "nic nie wpisałeś");
            Console.WriteLine(y); //Jeśli jest 0 wtedy wartośc zmiennej "o" nie jst określona

Użycie słowa kluczowego const do deklarowania stałego pola lub stałego lokalnego. Stałe pola nie są zmiennymi i nie mogą być modyfikowane. wartości stałe mogą być liczbami, wartościami logicznymi, łańcuchami znaków lub odniesieniami zerowymi. Nie twórz stałej, aby reprezentowała informacje, które oczekujesz na zmiany w dowolnym momencie. Na przykład nie używaj stałego pola, aby zapisać cenę usługi, numer wersji produktu lub nazwę firmy. Wartości te mogą się zmieniać w czasie, a ponieważ kompilatory propagują stałe. Dobrym przykładem jest tutaj stała PI lub liczba Eulera:

            const double PI = 3.141592653589793238462643383279502884197169399;
            const string nazwaStrony = "VisualMonsters";

Takie zadeklarowanie stałej nie pozwoli na jej modyfikacje. Warto tutaj również wspomnieć o jeszcze jednej bardzo ważnej rzeczy jaką są liczby losowe. Deklaracja losowej liczby w C# jest bardzo porsta:

            Random rnd = new Random();
            int miesiac = rnd.Next(1, 13);  // miesiac: >= 1 and < 13
            int kostka = rnd.Next(1, 7);    // kostka:  >= 1 and < 7
            int karta = rnd.Next(52);      // karta:  >= 0 and < 52

Liczby wygenerowane tą metodą, nie są do końca losowe, dlatego mówi się na liczby wygenerowane w ten sposób „pseudo losowe”. Mechanizm generujący liczby losowe ma swój punkt startowy, powoduje to pewien problem w momencie, w którym chcemy zadeklarować kilka takich mechanizmów. Zadeklarowanie ich w tym samym momencie skutkować będzie wygenerowaniem jednakowych liczb.

            Random rnd = new Random();
            Console.WriteLine(rnd.Next(0, 13));
            Console.WriteLine(rnd.Next(0, 13));
            Console.WriteLine(rnd.Next(0, 13));

            Random rnd = new Random();
            Random rnd2 = new Random();
            Random rnd3 = new Random();
            Console.WriteLine(rnd.Next(0, 13));
            Console.WriteLine(rnd2.Next(0, 13));
            Console.WriteLine(rnd3.Next(0, 13));

Do generowania liczb losowych używany jest czas, bardzo mały odcinek czasu, na jego podstawie obliczana jest liczba losowa. Generując mechanizmy w tym samym czasie, ustawiliśmy ich start w tym samym momencie, zatrzymując je, zaraz po sobie zatrzymały się równocześnie, dlatego otrzymaliśmy takie same wartości.

1. Napisz program sprawdzający długość najdłuższego boku trójkąta prostokątnego (Twierdzenie Pitagorasa):
   Jeżeli trójkąt jest prostokątny to suma kwadratów długości dwóch krótszych boków trójkąta jest równa kwadratowi długości najdłuższego boku.
   a2+b2=c2
   a,b- długości przyprostokątnych
   c- długość przeciwprostokątnej
   (Użytkownik musi mieć możliwość wprowadzenia długości boku a i długości boku b,)
   Odpowiedź, zadanie 1 (158 Rozwiń)

           static void Main(string[] args)
           {
   
               double a;
               double b;
   
               Console.WriteLine("Twierdzenie Pitagorasa");
               Console.Write("Wprowadź długość przyprostokątnej a= ");
               double.TryParse(Console.ReadLine(), out a);
               Console.Write("Wprowadź długość przyprostokątnej b= ");
               double.TryParse(Console.ReadLine(), out b);
               Console.Write("Długość przeciwprostokątnej wynosi: ");
               Console.Write(Math.Sqrt(Math.Pow(a, 2) + Math.Pow(b, 2)));
   
           }

2. Oblicz wartość wyrażenia:  
   Odpowiedź, zadanie 2 (7 Rozwiń)

   Console.WriteLine(Math.Pow(15 + Math.Pow(184, 8), (1d / 5)));

3. Używając powyższych metod sprawdź czy wyrażenia są poprawne dla x = 24
   Odpowiedź, zadanie 3 (65 Rozwiń)

               Console.WriteLine(Math.Sqrt(24) + "=" +(Math.Pow(Math.E,(Math.Log(24)/2))));
               //lub
               Console.WriteLine(Math.Sqrt(24) + "=" + (Math.Exp(Math.Log(24) / 2)));
   
               Console.WriteLine(Math.Sqrt(24) + "=" + (Math.Pow(10, (Math.Log10(24) / 2))));