Hem C hem de C ++ 'da geçerli olan kod, her dilde derlendiğinde farklı davranışlar üretebilir mi?

C ve C ++ 'nın birçok farkı vardır ve geçerli C kodlarının tümü geçerli C ++ kodu değildir.
("Geçerli" ile tanımlanmış davranışa sahip standart kodu kastediyorum, yani uygulamaya özgü / tanımsız / vb. Değil)

C ve C ++ 'da geçerli bir kod parçasının, her dilde standart bir derleyici ile derlendiğinde farklı davranışlar üretebileceği herhangi bir senaryo var mı ?

Makul / yararlı bir karşılaştırma yapmak için (pratikte yararlı bir şey öğrenmeye çalışıyorum, soruda belirgin boşluklar bulmaya çalışmıyorum), varsayalım:

• Önişlemci ile ilgili hiçbir şey yok (bu, hiçbir hack #ifdef __cplusplus, pragmas vb.
• Uygulama tanımlı her şey her iki dilde de aynıdır (örn. Sayısal sınırlar, vb.)
• Her standardın makul sürümlerini karşılaştırıyoruz (örneğin, C ++ 98 ve C90 veya üstü)
  Sürümler önemliyse, lütfen her birinin hangi sürümlerinin farklı davranışlar ürettiğini belirtin.

C ve C ++ için geçerli olan aşağıdakiler (büyük olasılıkla) iC ve C ++ 'da farklı değerlerle sonuçlanır :

int i = sizeof('a');

Farkın açıklaması için C / C ++ 'daki karakter boyutu (' a ') konusuna bakın .

Dan Bir diğeri bu makalede :

#include <stdio.h>

int  sz = 80;

int main(void)
{
    struct sz { char c; };

    int val = sizeof(sz);      // sizeof(int) in C,
                               // sizeof(struct sz) in C++
    printf("%d\n", val);
    return 0;
}

C ve C ++ 'da işlev çağrıları ve nesne bildirimleri arasındaki farkın yanı sıra C90'ın bildirilmemiş işlevlerin çağrılmasına izin verdiği gerçeğinden yararlanan bir örnek:

#include <stdio.h>

struct f { int x; };

int main() {
    f();
}

int f() {
    return printf("hello");
}

C ++ 'da geçici bir fşey yaratıldığından ve yok edildiğinden hiçbir şey yazdırmaz , ancak C90'da helloişlevler bildirilmeden çağrılabildiğinden yazdırılır .

Adın fiki kez kullanıldığını merak ediyorsanız , C ve C ++ standartları buna açıkça izin verir ve bir nesne yapmak struct fistiyorsanız, yapıyı istiyorsanız belirsizleştirmek veya structişlevi istiyorsanız bırakın .

C ++ ile C90 arasında, uygulama tanımlı olmayan farklı davranışlar elde etmenin en az bir yolu vardır. C90'ın tek satır yorumları yok. Biraz dikkatle, bunu C90 ve C ++ 'da tamamen farklı sonuçlara sahip bir ifade oluşturmak için kullanabiliriz.

int a = 10 //* comment */ 2 
        + 3;

C ++ 'da //, satırın sonuna kadar her şey bir yorumdur, bu yüzden bu şu şekilde çalışır:

int a = 10 + 3;

C90'ın tek satır yorumları olmadığından, yalnızca /* comment */bir yorumdur. İlk /ve 2her ikisi de başlatmanın parçalarıdır, bu yüzden ortaya çıkar:

int a = 10 / 2 + 3;

Yani, doğru bir C ++ derleyici 13, ama kesinlikle doğru bir C90 derleyici 8 verecektir. Tabii ki, ben burada rastgele sayılar seçtim - uygun gördüğünüz gibi diğer numaraları kullanabilirsiniz.

C90 ve C ++ 11 ( intvs. double):

#include <stdio.h>

int main()
{
  auto j = 1.5;
  printf("%d", (int)sizeof(j));
  return 0;
}

C cinsinden auto yerel değişken anlamına gelir. C90'da değişken veya işlev türünü atlamak uygundur. Varsayılan olarak int. C ++ 11'de autotamamen farklı bir şey ifade eder, derleyiciye değişken türünü başlatmak için kullanılan değerden çıkarmasını söyler.

Daha önce bahsetmediğim başka bir örnek, bu bir önişlemci farkını vurgulamaktadır:

#include <stdio.h>
int main()
{
#if true
    printf("true!\n");
#else
    printf("false!\n");
#endif
    return 0;
}

Bu, C'de "false" ve C ++ 'da "true" yazdırır. C'de, tanımsız herhangi bir makro 0 olarak değerlendirilir. C ++' da 1 istisna vardır: "true" 1 olarak değerlendirilir.

C ++ 11 standardına göre:

a. Virgül operatörü, C ++ 'da lvalue-rvalue dönüşümü gerçekleştirir, ancak C ++' da değil:

   char arr[100];
   int s = sizeof(0, arr);       // The comma operator is used.

C ++ 'da bu ifadenin değeri 100 ve C' de bu olacaktır sizeof(char*).

b. C ++ 'da numaralandırıcı türü numaralandırmasıdır. C'de sayıcı türü int.

   enum E { a, b, c };
   sizeof(a) == sizeof(int);     // In C
   sizeof(a) == sizeof(E);       // In C++

Bu, sizeof(int)eşit olmayabileceği anlamına gelir sizeof(E).

c. C ++ 'da boş params listesiyle bildirilen bir işlev argüman almaz. C'de boş parametreler listesi, işlev parametrelerinin sayısı ve türünün bilinmediği anlamına gelir.

   int f();           // int f(void) in C++
                      // int f(*unknown*) in C

Bu program 1C ++ ve C olarak yazdırılır 0:

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int d = (int)(abs(0.6) + 0.5);
    printf("%d", d);
    return 0;
}

Olduğundan bu olur double abs(double), C ++ aşırı yük böylece abs(0.6)getiri 0.6C döndürür iken 0, çünkü çağırmadan önce örtük çift to-int dönüşüm int abs(int). C fabsile çalışmak için kullanmanız gerekir double.

#include <stdio.h>

int main(void)
{
    printf("%d\n", (int)sizeof('a'));
    return 0;
}

C'de, bu sizeof(int), geçerli sistemdeki değeri ne olursa olsun yazdırır.4 günümüzde yaygın olarak kullanılan çoğu .

C ++ 'da, bu 1 yazmalıdır.

Başka bir sizeoftuzak: boole ifadeleri.

#include <stdio.h>
int main() {
    printf("%d\n", (int)sizeof !0);
}

Bu sizeof(int)ifade C'ye eşittir , çünkü ifade tiptir int, ancak genellikle C ++ 'da 1'dir (olması gerekmese de). Pratikte neredeyse her zaman farklıdırlar.

C ++ Programlama Dili (3. Baskı) üç örnek verir:

1. @Adam Rosenfield'ın belirttiği gibi sizeof ('a');

2. // gizli kod oluşturmak için kullanılan yorumlar:

   int f(int a, int b)
   {
       return a //* blah */ b
           ;
   }

3. Örneğin vb. Gibi yapıları vb.

C derleyicisine bağlı, C ++ satır sonu yorumlarını tanımayan eski bir kestane ...

...
int a = 4 //* */ 2
        +2;
printf("%i\n",a);
...

C ++ Standardı tarafından listelenen bir diğeri:

#include <stdio.h>

int x[1];
int main(void) {
    struct x { int a[2]; };
    /* size of the array in C */
    /* size of the struct in C++ */
    printf("%d\n", (int)sizeof(x)); 
}

C ++ 'daki satır içi işlevler, C ++' daki gibi olmayan dış kapsama varsayılan değerdir.

Aşağıdaki iki dosyayı birlikte derlemek, GNU C durumunda "I inline" yazıyor ancak C ++ için hiçbir şey yazdırmıyor.

Dosya 1

#include <stdio.h>

struct fun{};

int main()
{
    fun();  // In C, this calls the inline function from file 2 where as in C++
            // this would create a variable of struct fun
    return 0;
}

Dosya 2

#include <stdio.h>
inline void fun(void)
{
    printf("I am inline\n");
} 

Ayrıca, C ++ , varsayılan olan C'den farklı constolarak , herhangi bir genel nesneyi static, açıkça bildirilmediği sürece dolaylı olarak ele alır .externextern

struct abort
{
    int x;
};

int main()
{
    abort();
    return 0;
}

C ++ 'da 0 veya C' de 3 çıkış koduyla döner.

Bu hile muhtemelen daha ilginç bir şey yapmak için kullanılabilir, ancak C'ye lezzetli olacak bir yapıcı oluşturmanın iyi bir yolunu düşünemedim. Kopya yapıcısıyla benzer şekilde sıkıcı bir örnek yapmaya çalıştım, taşınabilir olmayan bir şekilde de olsa geçilebilir:

struct exit
{
    int x;
};

int main()
{
    struct exit code;
    code.x=1;

    exit(code);

    return 0;
}

VC ++ 2005, C ++ modunda derlemeyi reddetti, ancak "çıkış kodu" nasıl yeniden tanımlandı şikayet. (Aniden nasıl programlanacağını unutmadıkça, bu bir derleyici hatası olduğunu düşünüyorum.) C olsa derlendiğinde 1 işlem çıkış kodu ile çıkıldı.

#include <stdio.h>

struct A {
    double a[32];
};

int main() {
    struct B {
        struct A {
            short a, b;
        } a;
    };
    printf("%d\n", sizeof(struct A));
    return 0;
}

Bu program, bir C ++ derleyicisi kullanılarak derlendiğinde 128( 32 * sizeof(double)) yazdırır ve4 kullanılarak derlendiğinde bir C derleyicisi kullanılarak .

Bunun nedeni, C'nin kapsam çözünürlüğü kavramına sahip olmamasıdır. C'de diğer yapılarda bulunan yapılar dış yapı kapsamına alınır.

C ve C ++ global ad alanları arasındaki farkı unutmayın. Bir foo.cpp dosyanız olduğunu varsayalım

#include <cstdio>

void foo(int r)
{
  printf("I am C++\n");
}

ve bir foo2.c

#include <stdio.h>

void foo(int r)
{
  printf("I am C\n");
}

Şimdi her ikisinin de benzediği bir main.c ve main.cpp dosyanız olduğunu varsayalım :

extern void foo(int);

int main(void)
{
  foo(1);
  return 0;
}

C ++ olarak derlendiğinde, C ++ global ad alanındaki sembolü kullanır; C'de C olanını kullanır:

$ diff main.cpp main.c
$ gcc -o test main.cpp foo.cpp foo2.c
$ ./test 
I am C++
$ gcc -o test main.c foo.cpp foo2.c
$ ./test 
I am C

int main(void) {
    const int dim = 5; 
    int array[dim];
}

Bu, C ++ ve C99, C11 ve C17'de (C11, C17'de isteğe bağlı olmasına rağmen) geçerli olması bakımından oldukça tuhaftır; ancak C89'da geçerli değildir.

C99 + 'da, derleme zamanı türü yerine bir çalışma zamanı türüne sahip sizeof arrayolduğu ve C'de bir tamsayı sabit ifadesi olmadığı için normal diziler üzerinde kendine özgü özellikleri olan değişken uzunluklu bir dizi oluşturur . C ++' da tür tamamen statiktir.

Buraya bir başlatıcı eklemeye çalışırsanız:

int main(void) {
    const int dim = 5; 
    int array[dim] = {0};
}

değişken uzunluktaki dizilerin bir başlatıcısı bulunamadığından , geçerli C ++ ancak C değil.

Bu, C ve C ++ 'da değer ve değerlerle ilgilidir.

C programlama dilinde, hem artım öncesi hem de artım sonrası işleçleri, değerleri değil, değerleri döndürür. Bu, =atama operatörünün sol tarafında olamayacakları anlamına gelir . Bu ifadelerin her ikisi de C'de bir derleyici hatası verecektir:

int a = 5;
a++ = 2;  /* error: lvalue required as left operand of assignment */
++a = 2;  /* error: lvalue required as left operand of assignment */

C ++, ancak önceden arttırma operatör döner lvalue artırma sonrası operatör rvalue döndürür iken,. Bu, ön artış operatörü ile bir ifadenin =atama operatörünün sol tarafına yerleştirilebileceği anlamına gelir !

int a = 5;
a++ = 2;  // error: lvalue required as left operand of assignment
++a = 2;  // No error: a gets assigned to 2!

Şimdi neden böyle? Artırma sonrası değişken artırır ve olduğu gibi değişken döndürür önce artış oldu. Bu aslında sadece bir değerdir. A değişkeninin eski değeri geçici olarak bir kayıt defterine kopyalanır ve sonra a artırılır. Ancak a'nın eski değeri ifade tarafından döndürülür, bu bir değerdir. Artık değişkenin geçerli içeriğini temsil etmemektedir.

Önceden arttırma ilk artışlarla değişken ve oldu gibi o değişken döndürür sonra artış oldu. Bu durumda, değişkenin eski değerini geçici bir kayıt defterine depolamamız gerekmez. Değişkenin yeni değerini artırıldıktan sonra alırız. Böylece ön artış bir lvalue, değişken a'nın kendisini döndürür. Bu değeri başka bir şeye atamak için kullanabiliriz, aşağıdaki ifadeye benzer. Bu, değerin örtük bir değere dönüştürülmesidir.

int x = a;
int x = ++a;

Ön artış bir değer döndürdüğü için, buna bir şey de atayabiliriz. Aşağıdaki iki ifade aynıdır. İkinci ödevde, önce a artırılır, daha sonra yeni değerinin üzerine 2 yazılır.

int a;
a = 2;
++a = 2;  // Valid in C++.

Boş yapılar C boyutunda 0 ve C ++ 'da 1 boyuta sahiptir:

#include <stdio.h>

typedef struct {} Foo;

int main()
{
    printf("%zd\n", sizeof(Foo));
    return 0;
}