po1_w1 [tryb zgodności]

Środowisko

Visual Studio 2008

• Środowisko Visual Studio 2008

Professional Edition dostępne
bezpłatnie dla studentów poprzez
MSDN AA

• Środowisko Visual Studio 2008

Express Edition dostępne bezpłatnie
dla każdego użytkownika ze stron
MSDN

Dane w C#

• C# jest językiem mocno typowanym
• Oznacza to, że, w odróżnieniu np. od

Pythona, tworząc zmienne musimy
określić ich typ, a konwersje między
różnymi typami muszą być
wykonane jawnie

• W C# dostępnych jest szereg typów

prostych oraz liczne typy złożone

Typy proste

• Logiczny: bool

– Wartości: true, false

• Całkowite

– 8 bitowe: sbyte, byte, 16 bitowe: short, ushort, char

(znak w apostrofach), 32 bitowe: int, uint, 64 bitowe:
long, ulong

• Rzeczywiste

– Zmiennopozycyjne binarne: float, double,

zmiennopozycyjny dziesiętny: decimal

• Napisowy: string

– Napis w cudzysłowach
– Backslash ma znaczenie specjalne, np. ‘\n’
– @ wyłącza znaczenie specjalne, np. @„c:\n”

Tworzenie zmiennych typów

prostych

• Składnia: nazwa_typu nazwa_zmiennej;
• Przykłady:
int index;
int i, j, k;
long number_of_seconds_in_a_year;
real x, y, z, pi;
double d;
bool b, is_ok;

Nazwy zmiennych

• Reguły tworzenia własnych nazw w

C#:

–

Zaczynamy literą lub znakiem
podkreślenia

–

Kontynuujemy cyfrą, literą lub znakiem
podkreślenia

–

Długość nazw jest nieograniczona

–

Wielkość liter ma znaczenie!

Konwencje nazewnicze

• Styl Pascala

– pierwsza litera każdego słowa w nazwie

jest dużą literą, np.
SredniaPredkoscNaGodzine

– zalecany do nazywania klas i metod

• Styl Camela

– jak Pascala, z tą róznicą, że pierwsze

słowo identyfikatora jest pisane małymi
literami, np. sredniaPredkoscNaGodzine

– służy do nazywania zmiennych

Przestrzenie nazw

• Może się zdarzyć, że w tym samym programie używa się

takich samych nazw na określenie zupełnie różnych danych

• Przydatne wtedy są przestrzenie nazw, grupujące dane pod

wspólną nazwą kategorii

• Składnia definicji przestrzeni nazw jest następująca:
namespace NAZWA_PRZESTRZENI {
ZAWARTOŚĆ
}
• Elementy przestrzeni wywołuje się łącząc kropką nazwę

przestrzeni i nazwę jej elementu, np.:

NAZWA_PRZESTRZENI.NAZWA_ELEMENTU
• Przy pomocy słowa using możemy wskazać używane

przestrzenie nazw:

using NAZWA_PRZESTRZENI;

Instrukcja przypisania

• Instrukcja przypisania ma postać:

zmienna = wyrażenie;

• Jej działanie polega na nadaniu zmiennej

o podanej nazwie (lewa strona)
obliczonej wartości wyrażenia (prawa
strona), np.:

• Jeżeli wyrażenie zawiera nazwę funkcji,

zostanie ona wykonana, np.:

Instrukcja

Wynik

a=1;

a równe 1

b=2+3;

b równe 5

c=a+b;

c równe sumie a i b

Instrukcja

Wynik

a=Console.ReadLine(); wczyta warto

ść

a z klawiatury

Konwersja typów

• Dane typów węższych mogą być konwertowane

niejawnie na typy szersze, np.:

byte b = 5;
int i = b;
long l = i;

• Każda inna konwersja może prowadzić do

zniekształcenia informacji, musi mieć więc postać
jawną, z podaniem nazwy typu docelowego
w nawiasach, np.:

int i = (int) l;
double d = 5.3;
int i = (int) d;

Podstawowe operatory

Dodawanie

Logiczne LUB

Odejmowanie

Logiczne I

Mno

enie

Logiczne NIE

Dzielenie

Mniejszy

Reszta z dzielenia

kszy

Iloczyn bit

Mniejszy r

wny

Suma bit

kszy r

wny

óż

nica symetryczna

wny

Negacja bit

Nier

wny

Przesuni

cie bit

w w lewo

samy

Przesuni

cie bit

w w prawo

? :

Operator ternarny

Instrukcje modyfikacji

• Odmianą instrukcji przypisania są instrukcje

modyfikacji, służące do zmiany wartości
zmiennych

• Instrukcje modyfikacji mają postać

zmienna

= wyrażenie;

gdzie

oznacza operator, np.: +, -, *

• Instrukcje modyfikacji wprowadzono dla

wygody programisty, każdą instrukcję
modyfikacji można zapisać jako instrukcję
przypisania, np.:

Instrukcja

Wynik

Odpowiednik

a+=1;

zwi

kszy a o 1

a=a+1;

b-=a;

odejm ie od b zawarto

ść

b=b-a;

Instrukcje in/dekrementacji

• Odmianą instrukcji modyfikacji są instrukcje

inkrementacji i dekrementacji, służące do zwiększenia

lub zmniejszenia wartości zmiennych o 1

• Są cztery takie instrukcje:

– zmienna++;
– ++zmienna;
– zmienna--;
– --zmienna;

• Instrukcje inkrementacji i dekrementacji nie tylko

zmieniają wartość zmiennej, ale, w odróżnieniu od

instrukcji modyfikacji, zwracają ją, mogą być zatem

użyte w złożonych wyrażeniach

Instrukcja

Wynik

++a;

zwi

kszy a o 1, zwróci warto

ść

zwi

kszon

b--;

zmniejszy b o 1, zwróci warto

ść

oryginaln

Program główny

class NazwaProgramu {

public static void Main() {

...

}

Wywołanie podprogramów

• Podprogramy (funkcje) wywołuje się poprzez podanie ich

nazwy koniecznie zakończonej parą nawiasów
okragłych (wewnątrz których można zamieścić ewentualne
parametry)

• Funkcje, które zwracają wartości wywołuje się w większym

wyrażeniu, np. przy okazji przypisania:

• Funkcje, które nie zwracają wartości lub nie interesują nas

one (tzw. procedury), wywołuje się samodzielnie:

Instrukcja

Efekt

a=Console.ReadLine();

Wprowadzi do a rezultat Console.ReadLine();

(wczyta warto

ść

a z klawiatury)

Console.ReadLine();

Czeka na wci

cie ENTER

Obowiązkowe nawiasy

Wyświetlanie

• Do wyświetlania danych na ekranie tekstowym służy

instrukcja Console.WriteLine

• Do oddzielania danych do wyświetlenia służy przecinek
• Po wyświetleniu tekstu, kursor przechodzi do nowej linii

– Aby tego uniknąć, używamy Console.Write

Instrukcja

Efekt

Console.WriteLine();

Pusta linia

Console.WriteLine(1);

wietlona 1

Console.WriteLine(a);

wietlona zawarto

ść

zmiennej a

Console.WriteLine("a");

wietlona litera a

Console.WriteLine(a+2); Wy

wietlona warto

ść

a zwi

kszona o 2

Instrukcja skoku

int a = 0;
start:
System.Console.WriteLine(a);
a++;
goto start;

• Instrukcja skoku powoduje przejście

do podanej linii programu (etykiety)

Typy konstrukcji

programistycznych

• Zgodnie z teorią programowania

strukturalnego, każdy program da się
przedstawić używając
tylko trzech rodzajów konstrukcji:

– Sekwencji (ciąg instrukcji wykonywany zawsze

tylko jeden raz, niezależnie od sytuacji)

– Wyboru (ciąg instrukcji, zależnie od sytuacji

wykonywany tylko jeden raz lub wcale)

– Pętli (ciąg instrukcji, wykonywany nieznaną

liczbę razy)

• Elementem konstrukcji mogą być

zarówno instrukcje proste, jak i złożone

– A zatem, można tworzyć dowolnie

skomplikowane konstrukcje hierarchiczne

Instrukcje złożone

• sekwencja
• wyrażenia warunkowe:

– wybór prosty
– wybór pełny
– wybór wielokrotny

• pętle:

– z testem na początku cyklu
– z testem na końcu cyklu
– o ustalonej liczbie cykli
– po elementach sekwencji

Sekwencja

• Sekwencja to ciąg instrukcji wykonywanych niezależnie

od okoliczności i tylko jeden raz

• W C# sekwencję tworzymy umieszczając instrukcje

wewnątrz nawiasów klamrowych:

Sekwencja1.Instrukcja1
Sekwencja1.Instrukcja2

{

Sekwencja1.2.Instrukcja1

{

Sekwencja1.2.1.Instrukcja1

}

Sekwencja1.Instrukcja3

• Sekwencje są wykorzystywane jako zawartość (ciało)

definicji funkcji i innych instrukcji złożonych (to jest

wyborów i pętli)

Wybór prosty

• Polega na wykonaniu instrukcji tylko

przy spełnieniu podanego warunku

• W C# zapiszemy go następująco:

if (WARUNEK)
{

Instrukcja_pod_warunkiem1;
Instrukcja_pod_warunkiem2;

}
Instrukcja_bez_warunku;

• Instrukcje w klamrach wykonają się tylko wtedy,

gdy wartość wyrażenia WARUNEK będzie
prawdziwa

Wybór prosty - przykład

if (a == 5)

System.Console.WriteLine("A to 5");

Wybór pełny

• Polega na wykonaniu przy spełnieniu

podanego warunku instrukcji A, a przy

jego niespełnieniu instrukcji B

• W Pythonie zapiszemy go następująco:

if (WARUNEK)
{

Instrukcja_pod_spelnionym_warunkiem;

}
else
{

Instrukcja_pod_niespelnionym_warunkiem;

}

Wybór pełny - przykład

if (a == 5)

System.Console.WriteLine("A to 5");

else

System.Console.WriteLine("A to nie 5");

System.Console.WriteLine(

a==5 ? "A to 5" : "A to nie 5");

To samo z użyciem operatora ternarnego:

Wybór wielokrotny

• Polega na wykonaniu przy spełnieniu podanego

warunku instrukcji A, przy spełnieniu innego

podanego warunku instrukcji B, ...,

a przy niespełnieniu żadnego z podanych

warunków instrukcji Z

• W C# zapiszemy go następująco:

switch (WYRAŻENIE)
{

case WARTOŚĆ1:

Instrukcja1;
break;

case WARTOŚĆ2:

Instrukcja2;
break;

default:

Instrukcja_inna;
break;

}

Wybór wielokrotny - przykład

switch(a)

{

case 0:

Console.WriteLine("a to 0");

break;

case 1:

case 2:

Console.WriteLine("a to 1 lub 2");

break;

default:

Console.WriteLine(

"a jest wi

ksze ni

2 ");

break;

}

Pętla

z testem na początku cyklu

• Polega na powtarzaniu wykonywania instrukcji

tak długo, jak zachodzi podany warunek

• W C# zapiszemy ją następująco:

while (WARUNEK)
{

Instrukcja_w_pętli

}

• Instrukcje w pętli wykonywane będą wiele razy,

aż warunek przestanie być spełniony

Pętla z testem na początku

cyklu - przykład

using System;

class WhileLoop

{

public static void Main()

{

int myInt = 0;

while (myInt < 10)

{

Console.Write("{0} ", myInt);

myInt++;

}

Console.WriteLine();

}

Pętla

z testem na końcu cyklu

• Polega na powtarzaniu wykonywania instrukcji

tak długo, jak zachodzi podany warunek, ale co
najmniej jeden raz

• W C# zapiszemy ją następująco:

do
{

Instrukcja_w_pętli

} while (WARUNEK)

• Instrukcje w pętli wykonywane będą wiele razy,

aż warunek przestanie być spełniony

Pętla z testem na końcu cyklu -

przykład

using System;

class WhileLoop

{

public static void Main()

{

int myInt = 0;

do {

Console.Write("{0} ", myInt);
myInt++;

} while (myInt < 10)

Console.WriteLine();

}

Pętla

o ustalonej liczbie cykli

• Polega na powtarzaniu wykonywania

instrukcji zadaną liczbę razy

• W C# zapiszemy ją następująco:
for (INICJACJA; WARUNEK;

MODYFIKACJA)

{

Instrukcja_w_pętli1

}

• Instrukcje w pętli

wykonane zostaną
zadaną liczbę razy

Pętla o ustalonej liczbie cykli -

przykład

using System;

class ForLoop

{

public static void Main()

{

for (int i=0; i < 20; i++)

{

if (i == 10)

break;

if (i % 2 == 0)

continue;

Console.Write("{0} ", i);

}

Console.WriteLine();

}

Pętla

po elementach sekwencji

• Polega na powtarzaniu wykonywania

instrukcji dla każdego elementu
sekwencji

• W C# zapiszemy ją następująco:
foreach (ZMIENNA in LISTA_WARTOŚCI)
{

Instrukcja_w_pętli

}

• Instrukcje w pętli

wykonane zostaną tyle razy, ile jest
elementów sekwencji

Pętla po elementach sekwencji

- przykład

using System;

class ForEachLoop

{

public static void Main()

{

string[] names = {"Cheryl", "Joe", "Matt",

"Robert"};

foreach (string person in names)

{

Console.WriteLine("{0} ", person);

}