wyklad5.cpp, JAVA jest językiem programowania obiektowego


Jak wygląda metoda strcmp ?

int strcmp(char* s, char* t)

{

for(int i=0; s[i]==t[i]; i++)

if(s[i]=='\0')

return 0;

return s[i]-t[i];

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

Pętla

for(int i=0; s[i]==t[i]; i++)

Na początku i=0

Wykonujemy wnętrze pętli (co to jest wnętrze pętli?)

Jak wygląda metoda strcmp ?

int strcmp(char* s, char* t)

{

for(int i=0; s[i]==t[i]; i++)

if(s[i]=='\0')

return 0;

return s[i]-t[i];

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

Wykonujemy wnętrze pętli (co to jest wnętrze pętli?)

if(s[i]=='\0')

return 0;

Czy s[0]=='\0'

NIE!

Więc co teraz?

Jak wygląda metoda strcmp ?

int strcmp(char* s, char* t)

{

for(int i=0; s[i]==t[i]; i++)

if(s[i]=='\0')

return 0;

return s[i]-t[i];

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

Sprawdzamy warunek zakończenia pętli

for(int i=0; s[i]==t[i]; i++)

s[0] to `J' t[0] to `J'

Czy s[0]==t[0] ? TAK, ponieważ `J'=='J'

Warunek jest spełniony, czy pętla skończy się teraz czy nie?

Jak wygląda metoda strcmp ?

int strcmp(char* s, char* t)

{

for(int i=0; s[i]==t[i]; i++)

if(s[i]=='\0')

return 0;

return s[i]-t[i];

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

Sprawdzamy warunek zakończenia pętli

for(int i=0; s[i]==t[i]; i++)

s[0] to `J' t[0] to `J'

Czy s[0]==t[0] ? TAK, ponieważ `J'=='J'

Warunek jest spełniony, czy pętla skończy się teraz czy nie?

NIE (pętla skończy się gdy warunek nie będzie spełniony)

Jak wygląda metoda strcmp ?

int strcmp(char* s, char* t)

{

for(int i=0; s[i]==t[i]; i++)

if(s[i]=='\0')

return 0;

return s[i]-t[i];

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

Więc co teraz? Wykonujemy następny przebieg pętli

for(int i=0; s[i]==t[i]; i++)

Poprzednio i==0,

i++ oznacza zwiększenie i o 1, mamy więc i==1

Jak wygląda metoda strcmp ?

int strcmp(char* s, char* t)

{

for(int i=0; s[i]==t[i]; i++)

if(s[i]=='\0')

return 0;

return s[i]-t[i];

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

i==1, wykonuje wnętrze pętli

if(s[i]=='\0')

return 0;

Czy s[1]=='\0' ?

s[1] to `o'

Warunek nie jest spełniony, więc co teraz?

Jak wygląda metoda strcmp ?

int strcmp(char* s, char* t)

{

for(int i=0; s[i]==t[i]; i++)

if(s[i]=='\0')

return 0;

return s[i]-t[i];

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

Sprawdzamy warunek zakończenia pętli

for(int i=0; s[i]==t[i]; i++)

s[1] to `o' t[1] to `a'

Czy s[1]==t[1] ?

NIE, ponieważ `o' != 'a'

Warunek nie jest spełniony, czy pętla skończy się teraz czy nie?

Jak wygląda metoda strcmp ?

int strcmp(char* s, char* t)

{

for(int i=0; s[i]==t[i]; i++)

if(s[i]=='\0')

return 0;

return s[i]-t[i];

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

TAK (pętla kończy się)

Co teraz?

Jak wygląda metoda strcmp ?

int strcmp(char* s, char* t)

{

for(int i=0; s[i]==t[i]; i++)

if(s[i]=='\0')

return 0;

return s[i]-t[i];

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

Teraz wykonujemy

return s[i]-t[i];

Co to jest s[i]-t[i] ?

Jak wygląda metoda strcmp ?

int strcmp(char* s, char* t)

{

for(int i=0; s[i]==t[i]; i++)

if(s[i]=='\0')

return 0;

return s[i]-t[i];

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

Teraz wykonujemy

return s[i]-t[i];

Co to jest s[i]-t[i] ?

s[1] -t[1]

s[1] to `o', t[1] to `a'

W jaki sposób C++ wykonuje odejmowanie dwóch liter (dwóch znaków) ?

Jak wygląda metoda strcmp ?

int strcmp(char* s, char* t)

{

for(int i=0; s[i]==t[i]; i++)

if(s[i]=='\0')

return 0;

return s[i]-t[i];

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

W jaki sposób C++ wykonuje odejmowanie dwóch liter (dwóch znaków) ?

Każda litera ma swój kod ASCII w C++

C++ zamienia litery na kody ASCII i odejmuje ich kody ASCII

Kody ASCII rosną alfabetycznie z literami, tak więc `o'-`a' to będzie odległość litery `o' od litery `a'

czyli 14 (`a' jest pierwszą literą, `o' jest pietnastą literą - bez Polskich znaków)

Inna wersja:

int strcmp(char* s, char* t)

{

for(; *s==*t; s++, t++)

if(s[i]=='\0')

return 0;

return *s-*t;

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

Pętla

for(; *s==*t; s++, t++)

Tym razem nie ma żadnego licznika, nic nie jest inicjowane na początku!

Wykonujemy wnętrze pętli (co to jest wnętrze pętli?)

Inna wersja:

int strcmp(char* s, char* t)

{

for(; *s==*t; s++, t++)

if(s[i]=='\0')

return 0;

return *s-*t;

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

for(; *s==*t; s++, t++)

Tym razem nie ma żadnego licznika, nic nie jest inicjowane na początku!

Wykonujemy wnętrze pętli (co to jest wnętrze pętli?)

if(s[i]=='\0')

return 0;

Czy s[0]=='\0'

NIE! Więc co teraz?

Inna wersja:

int strcmp(char* s, char* t)

{

for(; *s==*t; s++, t++)

if(s[i]=='\0')

return 0;

return *s-*t;

}

Przykład działania:

char* s

ADRES 123 124 125 126 127

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

ADRES 234 235 236 237

0

1

2

3

`J'

`a'

`n'

\0

Sprawdzamy warunek zakończenia pętli

for(; *s==*t; s++, t++)

Czy *s==*t ?

Co to jest *s, co to jest *t ???

s to wskaźnik do zerowego wyrazy tablicy, czyli adres litery `J' w pierwszej tablicy czyli 123

t to wskaźnik do zerowego wyrazy tablicy, czyli adres litery `J' w drugiej tablicy czyli 234

Inna wersja:

int strcmp(char* s, char* t)

{

for(; *s==*t; s++, t++)

if(s[i]=='\0')

return 0;

return *s-*t;

}

Przykład działania:

char* s

ADRES 123 124 125 126 127

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

ADRES 234 235 236 237

0

1

2

3

`J'

`a'

`n'

\0

Co to jest *s, co to jest *t ???

s to wskaźnik do zerowego wyrazy tablicy, czyli adres litery `J' w pierwszej tablicy czyli 123

*s to to co siedzi w tym miejscu w pamięci, czyli litera `J'

t to wskaźnik do zerowego wyrazy tablicy, czyli adres litery `J' w drugiej tablicy czyli 234

*s to to co siedzi w tym miejscu w pamięci, czyli litera `J'

Czy *s==*t ???

Inna wersja:

int strcmp(char* s, char* t)

{

for(; *s==*t; s++, t++)

if(s[i]=='\0')

return 0;

return *s-*t;

}

Przykład działania:

char* s

ADRES 123 124 125 126 127

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

ADRES 234 235 236 237

0

1

2

3

`J'

`a'

`n'

\0

Czy *s==*t ???

TAK

`J'=='J'

Warunek jest spełniony, czy pętla zakończy się?

Inna wersja:

int strcmp(char* s, char* t)

{

for(; *s==*t; s++, t++)

if(s[i]=='\0')

return 0;

return *s-*t;

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

Warunek jest spełniony, czy pętla skończy się teraz czy nie?

NIE (pętla skończy się gdy warunek nie będzie spełniony)

Inna wersja:

int strcmp(char* s, char* t)

{

for(; *s==*t; s++, t++)

if(s[i]=='\0')

return 0;

return *s-*t;

}

Przykład działania:

char* s

ADRES 123 124 125 126 127

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

ADRES 234 235 236 237

0

1

2

3

`J'

`a'

`n'

\0

Więc co teraz? Wykonujemy następny przebieg pętli

for(; *s==*t; s++, t++)

s to wskaźnik do zerowego wyrazy tablicy, czyli adres litery `J' w pierwszej tablicy czyli 123

t to wskaźnik do zerowego wyrazy tablicy, czyli adres litery `J' w drugiej tablicy czyli 234

s++ oznacza przesunięcie pierwszego wskaźnika na następny element tablicy, czyli z `J' na `o'

t++ oznacza przesunięcie pierwszego wskaźnika na następny element tablicy, czyli z `J' na `a'

Inna wersja:

int strcmp(char* s, char* t)

{

for(; *s==*t; s++, t++)

if(s[i]=='\0')

return 0;

return *s-*t;

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

wykonujemy wnętrze pętli

if(s[i]=='\0')

return 0;

Czy s[1]=='\0' ?

s[1] to `o'

Warunek nie jest spełniony, więc co teraz?

Inna wersja:

int strcmp(char* s, char* t)

{

for(; *s==*t; s++, t++)

if(s[i]=='\0')

return 0;

return *s-*t;

}

Przykład działania:

char* s

ADRES 123 124 125 126 127

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

ADRES 234 235 236 237

0

1

2

3

`J'

`a'

`n'

\0

Sprawdzamy warunek zakończenia pętli

for(; *s==*t; s++, t++)

s to wskaźnik do pierwszego wyrazy tablicy, czyli adres litery `o' w pierwszej tablicy czyli 124

*s to to co siedzi w tym miejscu w pamięci, czyli litera `o'

t to wskaźnik do pierwszego wyrazy tablicy, czyli adres litery `a' w drugiej tablicy czyli 235

*t to to co siedzi w tym miejscu w pamięci, czyli litera `a'

Inna wersja:

int strcmp(char* s, char* t)

{

for(; *s==*t; s++, t++)

if(s[i]=='\0')

return 0;

return *s-*t;

}

Przykład działania:

char* s

ADRES 123 124 125 126 127

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

ADRES 234 235 236 237

0

1

2

3

`J'

`a'

`n'

\0

Czy *s==*t ???

NIE

`o' !='a'

Warunek nie jest spełniony, czy pętla zakończy się?

Inna wersja:

int strcmp(char* s, char* t)

{

for(; *s==*t; s++, t++)

if(s[i]=='\0')

return 0;

return *s-*t;

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

TAK (pętla kończy się)

Co teraz?

Inna wersja:

int strcmp(char* s, char* t)

{

for(; *s==*t; s++, t++)

if(s[i]=='\0')

return 0;

return *s-*t;

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

Teraz wykonujemy

return s[i]-t[i];

Co to jest s[i]-t[i] ?

Inna wersja:

int strcmp(char* s, char* t)

{

for(; *s==*t; s++, t++)

if(s[i]=='\0')

return 0;

return *s-*t;

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

Teraz wykonujemy

return s[i]-t[i];

Co to jest s[i]-t[i] ?

s[1] -t[1]

s[1] to `o', t[1] to `a'

W jaki sposób C++ wykonuje odejmowanie dwóch liter (dwóch znaków) ?

Inna wersja:

int strcmp(char* s, char* t)

{

for(; *s==*t; s++, t++)

if(s[i]=='\0')

return 0;

return *s-*t;

}

Przykład działania:

char* s

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* t

0

1

2

3

`J'

`a'

`n'

\0

W jaki sposób C++ wykonuje odejmowanie dwóch liter (dwóch znaków) ?

Każda litera ma swój kod ASCII w C++

C++ zamienia litery na kody ASCII i odejmuje ich kody ASCII

Kody ASCII rosną alfabetycznie z literami, tak więc `o'-`a' to będzie odległość litery `o' od litery `a'

czyli 14 (`a' jest pierwszą literą, `o' jest pietnastą literą - bez Polskich znaków)

Inne pożyteczne metody globalne do manipulowania tekstami:

//metoda do kopiowania tekstu t do tekstu s

void strcpy(char* s, char* t)

{

while(*s++=*t++);

}

Przykład działania:

char* t

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* s

0

1

2

3

4

s i t muszą być odpowiedniej długości (tej samej długości)

while(*s++=*t++);

Co wykonuje się na początku przebiegu pętli?

Co to jest wnętrze pętli w tym przykładzie?

Inne pożyteczne metody globalne do manipulowania tekstami:

//metoda do kopiowania tekstu t do tekstu s

void strcpy(char* s, char* t)

{

while(*s++=*t++);

}

Przykład działania:

char* t

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* s

0

1

2

3

4

while(*s++=*t++);

Co wykonuje się na początku przebiegu pętli?

Sprawdzenie warunku *s++=*t++

Co to jest wnętrze pętli w tym przykładzie?

NIC ;

Czyli pętla wykonuje w kółko sprawdzenie warunku *s++=*t++

Inne pożyteczne metody globalne do manipulowania tekstami:

//metoda do kopiowania tekstu t do tekstu s

void strcpy(char* s, char* t)

{

while(*s++==*t++);

}

Przykład działania:

char* t

ADRES 123 124 125 126 127

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* s

ADRES 234 235 236 237 238

0

1

2

3

4

Co oznacza sprawdzenie warunku

*s++=*t++ ??? UWAGA = to jest jedno równa się, nie dwa !!!

NAJPIERW weź *t (czyli literę pod adresem 123 na którą wskazuję wskaźnik t) oraz miejsce na które wskazuje s (czyli adres 234)

Następnie wykonaj PODSTAWIENIE *s=*t

Czyli przepisz `J' z adresu 123 adresu 234

Inne pożyteczne metody globalne do manipulowania tekstami:

//metoda do kopiowania tekstu t do tekstu s

void strcpy(char* s, char* t)

{

while(*s++==*t++);

}

Przykład działania:

char* t

ADRES 123 124 125 126 127

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* s

ADRES 234 235 236 237 238

0

1

2

3

4

`J'

POJAWIŁO SIĘ `J' przepisane z t do s

Żeby

*s++=*t++

było warunkiem stosowanym w pętli while, musi zwracać wartość logiczną (true albo false)

A jest to przepisanie znaku z t do s.

*s++=*t++ (tak samo jako *s=*t) zwraca ten właśnie znak. Jeśli nie jest to `\0' to C++ zamienia ten znak na true, a jeśli jest to `\0' to C++ zamienia ten znak na false

W tym przypadku `J' to nie jest `\0' więc dostaniemy true

Inne pożyteczne metody globalne do manipulowania tekstami:

//metoda do kopiowania tekstu t do tekstu s

void strcpy(char* s, char* t)

{

while(*s++==*t++);

}

Przykład działania:

char* t

ADRES 123 124 125 126 127

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* s

ADRES 234 235 236 237 238

0

1

2

3

4

`J'

Na końcu wykonania

*s++==*t++

zostają wykonane s++ oraz t++, czyli wskaźniki s i t zostają przesunięte na następną literę

Ponieważ przepisana litera to nie było `\0', więc wyrażenie

*s++==*t++

ma wartość true, więc pętla wykona się jeszcze raz

Inne pożyteczne metody globalne do manipulowania tekstami:

//metoda do kopiowania tekstu t do tekstu s

void strcpy(char* s, char* t)

{

while(*s++==*t++);

}

Przykład działania:

char* t

ADRES 123 124 125 126 127

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* s

ADRES 234 235 236 237 238

0

1

2

3

4

`J'

`o'

Tym razem

*s++==*t++

spowoduje przepisanie litery `o', która nie jest `\0', więc wyrażenie

*s++==*t++

ma wartość true, wskaźniki przesuną się dalej, i pętla wykona się jeszcze raz

Inne pożyteczne metody globalne do manipulowania tekstami:

//metoda do kopiowania tekstu t do tekstu s

void strcpy(char* s, char* t)

{

while(*s++==*t++);

}

Przykład działania:

char* t

ADRES 123 124 125 126 127

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* s

ADRES 234 235 236 237 238

0

1

2

3

4

`J'

`o'

`h'

Tym razem

*s++==*t++

spowoduje przepisanie litery `h', która nie jest `\0', więc wyrażenie

*s++==*t++

ma wartość true, wskaźniki przesuną się dalej, i pętla wykona się jeszcze raz

Inne pożyteczne metody globalne do manipulowania tekstami:

//metoda do kopiowania tekstu t do tekstu s

void strcpy(char* s, char* t)

{

while(*s++==*t++);

}

Przykład działania:

char* t

ADRES 123 124 125 126 127

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* s

ADRES 234 235 236 237 238

0

1

2

3

4

`J'

`o'

`h'

`n'

Tym razem

*s++==*t++

spowoduje przepisanie litery `n', która nie jest `\0', więc wyrażenie

*s++==*t++

ma wartość true, wskaźniki przesuną się dalej, i pętla wykona się jeszcze raz

Inne pożyteczne metody globalne do manipulowania tekstami:

//metoda do kopiowania tekstu t do tekstu s

void strcpy(char* s, char* t)

{

while(*s++==*t++);

}

Przykład działania:

char* t

ADRES 123 124 125 126 127

0

1

2

3

4

`J'

`o'

`h'

`n'

`\0'

char* s

ADRES 234 235 236 237 238

0

1

2

3

4

`J'

`o'

`h'

`n'

Tym razem

*s++==*t++

spowoduje przepisanie znaku `\0', więc wyrażenie

*s++==*t++

ma wartość false więc pętla zakończy się



Wyszukiwarka

Podobne podstrony:
Wyklad 3-4, uwm wnt Mecha, SM 5, Programowanie obiektowe i strukturalne, Wykłady
Wyklad 5-6, uwm wnt Mecha, SM 5, Programowanie obiektowe i strukturalne, Wykłady
Porebski, Java, J?ZYKI PROGRAMOWANIA OBIEKTOWEGO
Programowanie obiektowe, CPP program, 1
Języki programowania zaliczenie wykłady Języki programowania3
Języki programowania zaliczenie wykłady Wykład 5
Języki programowania wykłady
Programowanie obiektowe, wyklad6-czesc1, Dziedziczenie wielobazowe
Co to jest klasa, Programowanie, wykłady C++
Podstawy programowania obiektowego cw3 cpp
Języki programowania wykłady
Języki programowania zaliczenie wykłady Opracowanie1 2
pytania z wykładu sciaga jezyki programowania
Podstawy programowania obiektowego, cw2 cpp
JavaScript- podstawy, Edukacja, studia, Semestr IV, Języki Programowania Wysokiego Poziomu, Java skr
Cwiczenie 1, uwm wnt Mecha, SM 5, Programowanie obiektowe i strukturalne, Wykłady
Języki programowania zaliczenie wykłady, Opracowanie1, Języki programowania
11 10 2011 programowanie obiektowe wykład
Wykład z programowania obiektowego, Informatyka, Semsetr 2, Programowanie obiektowe

więcej podobnych podstron