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ę