Was sind die Unterschiede zwischen C/C++? Eine Vergleichsmethode, die viele Menschen nicht kennen

C/C++ sollte anhand der Anzahl der Schlüsselwörter, Quelldateien, Variablendefinitions- oder Deklarationsorte, Funktionen und Standardparameter verglichen werden. Wenn Sie immer verwirrt sind, hilft Ihnen die Lektüre dieses Artikels.

C/C++-Vergleich unter folgenden Aspekten:

1. Anzahl der Schlüsselwörter:
   C-Sprache: C99 Version, 32 Schlüsselwörter
   C++: C98-Version, 63 Schlüsselwörter

2. Quelldatei:
   C-Quelldateisuffix .c, C++-Quelldateisuffix . cpp, wenn beim Erstellen der Quelldatei nichts angegeben wird, ist der Standardwert .cpp

3. Speicherort der Variablendefinition oder -deklaration:
   C-Sprache muss definiert sein die erste Zeile; C++ erfordert nicht, wenn eine Funktion keinen Rückgabewerttyp angibt, gibt sie standardmäßig den Typ int zurück.

   In C++ ist die Erkennung von Funktionsrückgabewerten strenger Gibt einen Wert zurück, er muss als void angegeben werden.
(2) Parameterliste
4. Wenn eine Funktion in der Sprache C keine Parameterliste angibt, kann sie standardmäßig eine beliebige Anzahl von Parametern akzeptieren. Aufgrund der strengen Parametertyperkennung sind Funktionen ohne Parameterliste standardmäßig ungültig und akzeptieren keine Parameter.

   
   
   Standardparameter:
   
   Standardparameter dient zur Angabe eines Standardwerts für den Parameter der Funktion beim Deklarieren oder Definieren der Funktion. Wenn beim Aufruf dieser Funktion keine tatsächlichen Parameter angegeben werden, wird der Standardwert verwendet, andernfalls werden die angegebenen tatsächlichen Parameter verwendet.
   

//1.实现缺省参数void Test(int a = 50){
    cout << a << endl;
}
int main(){    Test();    // 输出50
    Test(100); // 输出100}

5. (1) Alle Standardparameter: Geben Sie alle Standardwerte aller Parameter an //Code
   

   // 实现全缺省参数void Test(int a = 1,int b = 2,int c = 3)
   {    cout << a << "" <<" "<< b << "" <<" "<< c << endl; 
   }int main()
   {
       Test();//1 2 3
       Test(100);//100 2 3
       Test(100, 200);//100 200 3
       Test(100, 200, 300);//100 200 300}

   (2) Semi-Standardparameter: Es ist festgelegt, dass Standardwerte nur von rechts nach links übergeben werden können //Code

// 实现半缺省参数   注：缺省值只能从右往左传void Test1(int a = 1, int b = 2, int c = 3)
{    cout << a << "" << " " << b << "" << " " << c << endl;
}void Test2(int a , int b = 2, int c = 3)
{    cout << a << "" << " " << b << "" << " " << c << endl;
}void Test3(int a , int b , int c = 3)
{    cout << a << "" << " " << b << "" << " " << c << endl;
}void Test4(int a = 1, int b , int c = 3)//不能通过编译，因为它违背了缺省值只能从右往左依次来给这一规定{    cout << a << "" << " " << b << "" << " " << c << endl;
}void Test5(int a = 1, int b = 2, int c )//不能通过编译，因为它违背了缺省值只能从右往左依次来给这一规定{    cout << a << "" << " " << b << "" << " " << c << endl;
}void Test6(int a = 1, int b , int c )//不能通过编译，因为它违背了缺省值只能从右往左依次来给这一规定{    cout << a << "" << " " << b << "" << " " << c << endl;
}void Test7(int a , int b = 2, int c )//不能通过编译，因为它违背了缺省值只能从右往左依次来给这一规定{    cout << a << "" << " " << b << "" << " " << c << endl;
}int main()
{
    Test1();//1 2 3}

Hinweis:

a. 带缺省值的参数必须放在参数列表的最后面。
b. 缺省参数不能同时在函数声明和定义中出现，只能二者则其一，最好放在函数声明中。
c. 缺省值必须是常量或全局变量。

C-Sprache nicht Standardparameter unterstützen

Funktionsüberladung

Funktionsüberladung bezieht sich auf die Deklaration mehrerer gleichnamiger Funktionen mit ähnlichen Funktionen im gleichen Bereich. Die formalen Parameterlisten von Diese Funktionen mit demselben Namen (jede Nummer, jeder Typ, jede Typenreihenfolge) müssen unterschiedlich sein.

//函数重载void Add();void Add(int a);//行参个数不一样void Add(char b);//行参类型不同void Add(int a, char b);void Add(char a, int b);//行参类型的次序不同

Nur ​​die Art des Rückgabewerts ist unterschiedlich, was keine Funktionsüberladung darstellen kann.

• //仅仅返回值的类型不同，是不能构成函数重载的void Add(int a, int b)
  {}int Add(int a, int b)
  {    return a + b;
  }int main()
  {
      Add(1, 2);//因为这样会造成调用不明确，两函数都可以被调用
      return 0;
  }

Der Grund, warum C++ Funktionsüberladung unterstützt: Der VS-Editor kompiliert die Art der Funktionsparameter in den Namen der Funktion unten, also den ursprünglichen Funktionsnamen wird in einen anderen eindeutigen Namen geändert.

• int Add(int a, int b);    // ?Add@@YAHHH@Zchar Add(int a, int b);   // ?Add@@YADHH@Zchar Add(char a, char b); // ?Add@@YADDD@Z

Der Grund, warum die Sprache C keine Funktionsüberladung unterstützt: Der neu generierte Funktionsname ist immer noch derselbe. Fügen Sie einfach _
In C++ wird die Funktion gemäß dem C-Sprachstil kompiliert. Fügen Sie einfach

extern „c“ vor dem Funktionsnamen hinzu

• extern "C" int Add(char a, int b);

Zitat

• Es gibt zwei Methoden, Parameter an Funktionen in der C-Sprache zu übergeben: Übergabe nach Wert und

  Übergabe nach Adresse

Wertübergabe

: Während des Funktionsaufrufs wird eine temporäre Variable generiert und durch einen formalen Parameter ersetzt. Schließlich wird der Wert des tatsächlichen Parameters an die neu zugewiesene temporäre Variable übergeben ist der formale Parameter. Vorteile der Wertübergabe: Die Nebenwirkungen der Funktion wirken sich nicht auf die externen tatsächlichen Parameter aus.

Nachteile der Wertübergabe

: Externe Parameter können nicht durch Ändern von Parametern geändert werden.
Referenz übergeben: Während des Funktionsaufrufs wird eine temporäre Variable generiert und durch formale Parameter ersetzt, und schließlich wird die Adresse des tatsächlichen Parameters an die neu zugewiesene temporäre Variable übergeben.
Vorteile der Fingerübergabe: Platzersparnis, hohe Effizienz, Änderung von Parametern kann externe Ist-Parameter verändern.

Nachteile der Zeigerübergabe

: Zeiger sind unsicher und die Nebenwirkungen von Funktionen wirken sich auf externe tatsächliche Parameter aus.
in C++:
Referenz:

(1) Konzept: Referenz ist nicht die Neudefinition einer Variablen, sondern eine bestehende Variable Nach der Verwendung eines Alias ​​weist der Compiler keinen Speicherplatz für die Referenzvariable zu. Sie teilt sich denselben Speicherplatz mit ihrer Referenzvariablen.

(2) Form: Typ- und Referenzvariablenname = Referenzentität

//引用int main()
{    int a = 10;    int& ra = a;    printf("%p\n", a);    printf("%p\n", ra);//ra和a的地址相同，说明ra和a是同一个实体，他们共用同一块内存空间

    ra = 3;    printf("%d\n", a);//3
    return 0;
}

Hinweis:

   a. 引用在定义时，必须初始化。
   b. 一个变量可以被多次引用。
   c. 引用一旦引用了一个实体，就不能在引用其他实体。
   d. 引用变量的生命周期比实体的生命周期短。

(3) Wird oft zitiert

常引用int main()
{    const int a = 1;    //int& ra = a;//编译会出错，因为实体a是常量
    const int& ra = a;    double b = 12.34;    //int& rb = b;//编译会出错，因为类型不同
    const int& rb = b;    printf("rb=%d\n", rb);//rb=12
    b = 5.0;    printf("b=%f\n", b);//b=5.0
    printf("rb=%d\n", rb);//rb=12
    //b的值改变，但rb的值并没有随之改变，说明rb和b是两个不同的实体}

(4) Array-Referenz

//数组引用int a[10];//数组a的类型为 int[10]int(&ra)[10] = a;

(5) Referenzszenario:

a. Verwenden Sie Referenzen als Parameter von Funktionen, um tatsächliche Parameter zu ändern.

void Swap(int* pLeft, int* pRight)
{    int temp = *pLeft;    *pLeft = *pRight;    *pRight = temp;
}

void Swap(int& left, int& right)
{    int temp = left;
    left = right;
    right = temp;
}
//如果用引用时不想改变实参的值，则给引用前加const
void Swap(const int& left, const int& right);int main()
{    int a = 10;    int b = 20;
    Swap(&a, &b);//通过传地址来改变实参    printf(" a=%d ", a);    printf(" b=%d\n", b);

    Swap(a, b);//通过引用来改变实参    printf(" a=%d ", a);    printf(" b=%d\n", b);
}

b. Verwenden Sie Referenzvariablen als Rückgabewert der Funktion //Code

情形1：int& FunTest()
{    int a = 10;    return a;
}int main()
{    int b = FunTest();//将函数的返回值赋给了b
    printf("b=%d\n", b);//b=10
    printf("b=%d\n", b);//b=10
    printf("b=%d\n", b);//b=10
    return 0;
}

情形2：int& FunTest2()
{    int a = 10;    return a;
}int main()
{    int& b=FunTest2();//将函数的返回值作为实体，
    printf("b=%d\n", b);//b=10
    printf("b=%d\n", b);//随机值
    printf("b=%d\n", b);//随机值
    return 0;
}

情形3：int& FunTest3(int& a)
{
    a = 10;    return a;
}int main()
{    int b;    int& rb = FunTest3(b);    printf("b=%d\n", b);//b=10
    printf("rb=%d\n", rb);//rb=10
    printf("rb=%d\n", rb);//rb=10
    printf("rb=%d\n", rb);//rb=10
    return 0;
}
注意：不能返回栈空间上的引用

Vergleich von Wert, Referenz und Referenzeffizienz

//比较struct BigType
{    int array[10000];
};void FunTest(BigType bt)//传值或传址{}void FunTest(BigType& bt)//引用{}void TestFunTestRumTime()
{
    BigType bt;
    size_t Start = GetTickCount();    for (i = 0; i < 1000000; i++)
    {
        FunTest(bt);//传值或传引用
        FunTest(&bt);//传址
    }
    size_t End = GetTickCount();    printf("%d\n", End - Start);
}//此代码检测出传值最慢，而传址和引用速度快且用时差不多相同

Referenzen und Zeiger sind Was ist der Unterschied?

Gleiche Punkte:

Inhalt auflisten

Die zugrunde liegende Verarbeitungsmethode ist dieselbe, alles basiert auf Zeigern . realisiert.

• Der Typ des zugrunde liegenden Zeigers, der der Referenzvariablen entspricht:

• Der Typ der Referenzvariablenentität * const

• Unterschiede:

• Referenzen müssen initialisiert werden; Zeiger sind nicht erforderlich.

Ein Zeiger eines gemeinsamen Typs kann jederzeit auf ein beliebiges Objekt desselben Typs verweisen. Sobald eine Referenz auf eine Entität verweist, kann sie nicht auf andere Entitäten verweisen.

• Zeiger++: zeigt auf die nächste Adresse; Referenz++: gibt den numerischen Wert++ an.

• hat unterschiedliche Bedeutungen in Bezug auf sizeof: Das Referenzergebnis ist die Größe des Referenztyps und der Zeiger ist immer die Adresse * die Anzahl der vom Speicherplatz belegten Bytes.

• Zeiger müssen manuell adressiert werden; Referenzen werden vom Compiler adressiert.

• 引用比指针使用起来相对安全。

命名空间

在C++中，变量、函数和类都是大量存在的，这些变量、函数和类的名称将都存在于全局命名空间中，会导致很多冲突，使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染。

• 命名空间的定义

//命名空间namespace N1
{    int a = 30;    void FunTest()
    {        printf("N1::FunTest()\n");
    }
}//N1的命名空间int a = 20;void FunTest()
{    printf("::FunTest()\n");
}//在全局作用域中int main()
{    int a = 10;    printf("%d\n", a);    printf("%d\n", ::a);
    ::FunTest();    printf("%d\n", N1::a);
    N1::FunTest();    return 0;
}//命名空间的嵌套namespace N2
{    int a = 40;    void FunTest()
    {        printf("N2::FunTest()\n");
    }    namespace N3
    {        int a = 50;        void FunTest()
        {            printf("N2::N3::FunTest()\n");
        }
    }
}int main()
{
    N2::FunTest();
    N2::N3::FunTest();    return 0;
}// 在同一个工程里允许存在多个相同名称的命名空间，编译器最后会合成到同一个命名空间中namespace N1
{    int b = 70;    void Test()
    {        printf("N1::Test()\n");
    }
}

• 说明
  a.一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。
  b.没有名称的命名空间只能在当前文件中使用，它里面定义的变量相当于工程里面的全局变量。

• 命名空间的使用

//命名空间的使用namespace N1
{    int a = 1;    int b = 2;    int c = 3;    /*void FunTest1()
    {}
    void FunTest2()
    {}*/}//法二：using N1::b;//法三：using namespace N1;int main()
{    int a = 4;    //法一：
    printf("a=%d\n", N1::a);//a=1

    printf("b=%d\n", b);//b=2
    printf("c=%d\n", c);//c=3}

C++输入输出：

//代码

//C++输入输出#include <iostream>using namespace std;//std标准命名空间int main()
{    int a = 10;    double b = 3.14;    char c = &#39;c&#39;;    cout << a ;    cout << b << &#39;\n&#39;;    cout << c << endl;    cout << a << " " << b << " " << c << endl;    cin >> a ;    cin >> b >> c;    return 0;
}// cout:标准命名空间重输出流对象  <<输出操作符   // cin:标准命名空间重输入流对象   >>输入操作符

相关推荐：

C# 中的 == 和 equals()有什么区别  

C# 中的 == 和 equals()区别       

视频：C++视频教程

Das obige ist der detaillierte Inhalt vonWas sind die Unterschiede zwischen C/C++? Eine Vergleichsmethode, die viele Menschen nicht kennen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!