C/C++

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:

1. Jeżeli ma być obliczona wartość wyrażenia to jest to false:
   a = (c!=c++)
   a = 0;
2. 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

1. 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 ...