Czy C i C++ to to samo?
Nie!
C++ = C with classes :) To jest największa różnica. Resztę da sie jakoś przeżyć.
Powiem tylko tyle:
c != c++
c != c++
Ja nic nie sugeruję, ale to wyrażenie zwróci prawdę :-D ;-).
c != c++
Ja nic nie sugeruję, ale to wyrażenie zwróci prawdę :-D ;-).
No właśnie , przecież Cepa by nie kłamał ;)
NO dobra a czy c++ i c++Builder to to samo(coś jak pascal i delphi)?
c++ to język
BCB to środowisko programowania.
Czyli coś jak Pascal i Turbo Pascal lub Object Pascal i Delphi.
Ja nic nie sugeruję, ale to wyrażenie zwróci prawdę :-D ;-).
Pod warunkiem, że zadeklarujesz zmienną c. ;-)
c != c++
Ja nic nie sugeruję, ale to wyrażenie zwróci prawdę :-D ;-).
Nie jestem pewien:
Kompilator przecież zainterpretuje to jako:
c != c;
c++;
Czyż nie ??
[dopisane]
Zrobiłem eksperyment:
--BEGIN CODE--
#include
int main() {
int c = 10;
printf("%s\n", (c != c++) ? "true" : "false" );
}
--END CODE--
--BEGIN OUTPUT--
true
--END OUTPUT--
Ale dlaczego ??
Postanowiłem rozwiać wasze wątpliwości:
#include
int main()
{
char c;
if (c != c++)
printf(" c != c++");
}
Jaki efekt wykonania funkcji?
c != c++
:)
Czyli wyrażenie to jest prawdą. C jest czym innym niż C++
Wobec tego cepa powiedział prawdę, w co nie należało wątpić.
[dopisane]
Vogel:
najpierw jest obliczana warość wyrażenia.
if (c != c++)
to jest
a = c
c++
b = c
i z tego a != b
ale jeżeli masz:
if (c != ++c)
to ponieważ to jest preinkrementacja, to ++c jest wykonywane przed obliczeniem wartości
czyli
++c
a = c
b = c
i z tego mamy, że a == b
To jest nic. Już Marooned widział lepsze numery, gdzie standard ANSI C wysiada. Nie ma to jak asm :)
Nie ma to jak asm :)
Zgadza się. Tak więc postanowiłem przeanalizować kod w Assemblerze generowany przez Buildera 5.0. I zamiast ów eksperyment rozwiać całkowicie wszelkie nieścisłości, totalnie wszystko zaciemnił.
Otóż pod obróbkę poszły dwa bardzo podobne kody:
bool a;
int c = 2;
a = (c != c++);
a = (c != c++) ? true : false;
Chyba nic nie pokręciłem, ale z tego co znam C++ w obu przypadkach zmienna a powinna być jednakowa. Jednak gdyby tak było, nie czytalibyście tego postu. Oto kod w Assemblerze dla obu przypadków (komentarze dla nie znających Asma):
[code]
mov edx, [ebp-0x38] ; edx = c
cmp edx, [ebp-0x38] ; porównuje edx ze zmienną c
setnz cl ; cl = 1 jeśli powyższe porównanie zwróciło fałsz (w przeciwnym wypadku cl = 0)
and ecx, 1 ; nie istotne dla naszego problemu
mov [ebp-0x31], cl ; a = cl
inc dword ptr [ebp-0x38] ; c = c + 1
[/code]
2)
[code]
mov al,1 ; al = 1
mov edx, [ebp-0x38] ; edx = c
inc dword ptr [ebp-0x38] ; c = c + 1
cmp edx, [ebp-0x38] ; porównuje edx ze zmienną c
jnz A ; jeśli różne, to skacze do etykiety A
dec eax ; tu: al = 0
A:
mov [ebp-0x31], al ; a = al
[/code]
Jak widać, w przykładzie 1) następuje porównanie obu takich samych wartości i zmienna a przyjmuje wartość false. Następnie zwiększana jest o jeden zmienna c.
Natomiast w przykładzie 2) następuje porównanie zmiennej c z wartością (c+1). Zmienna a przyjmuje wartość true.
Nie wiem, jak Wy, ale ja już zgłupiałem. A może to wina godziny...
Hmm... Juz mi sie kompletnie wszystko pokręciło.
Jak na moj rozum to jesli mamy:
[code]int c;
c!=c++;[/code] // powinno dac falsz
bo z tego co czytalem najpierw powinno zostać wykonane c!=c;
co da fałsz, a następnie zostanie zwiekszona o 1 zmienna c.
Teraz to już mam mętlik w glowie.
Ja też myślę, że to wyrażenie powinno być zawsze fałszywe.
Ten program napisany w Visual C++ 7 wyświetla napis "false".
#include
int main(void)
{
char c = 0;
(c != c++) ? (cout
w vc++ 6
(c!=c++) - fałsz
(c!=++c) - fałsz
dziwne
albo najpierw jest inkrementacja a potem porównanie , albo odwrotnie(dziwne ze w obydwu przypadkach i ze po obydwu stronach)
Dryo:
najpierw jest obliczana warość wyrażenia.
if (c != c++)
to jest
a = c
c++
b = c
i z tego a != b
ale jeżeli masz:
if (c != ++c)
to ponieważ to jest preinkrementacja, to ++c jest wykonywane przed obliczeniem wartości
czyli
++c
a = c
b = c
i z tego mamy, że a == b
1 przypadek ^ wg mnie jest inaczej , najpierw porównanie apotem inkrementacja
2 przypadek ^ wg mnie
lewa strona bez zmian , a prawa sie inkrementuje , a potemporównianie
Ale ja już sam nie wiem .
W sumie jakby połaczyć rozumowanie Dryo do 2 wyniku z vc++ a moje do pierwszego wyniku to to stanie sie już jasne , ale i ta dziwny ten świat ;)
A JEDNAK DRYO MIAŁ RACJE W 2 PRZYPDAKU , A JA NIE ;D
Trouble: nie ja miałem rację, tylko kod :) Po prostu przejrzałem kod w asm.
Już zdążyłem standadrd ANSI/ISO C przejrzeć oraz znane bugi w standardzie - nic. Poza tym, że takiej rzeczy robić się nie powinno.
Jeżeli chodzi o c!=c++ to po prostu:
- Jeżeli ma być obliczona wartość wyrażenia to jest to false:
a = (c!=c++)
a = 0; - Jeżeli ta obliczona wartość ma być użyta w jakiejś instr. warunkowej to mamy true:
a = (c!=c++)?1:0;
if (c!=c++)
Ot tyle.
A tak w ogóle to powinno być tak:
c
- Jeżeli ta obliczona wartość ma być użyta w jakiejś instr. warunkowej to mamy true:
a = (c!=c++)?1:0;
if (c!=c++)
Ot tyle.
w VC++ 6 ZAWSZE w tych przypadkach zwracana jest wartośc false ...