Quelles sont les différences entre C/C++ ? Une méthode de comparaison que beaucoup de gens ne connaissent pas

C/C++ doit être comparé à partir du nombre de mots-clés, de fichiers sources, d'emplacements de définition ou de déclaration de variable, de fonctions et de paramètres par défaut. Si vous êtes toujours confus, la lecture de cet article vous aidera.

Comparaison du C/C++ sous les aspects suivants :

1. Nombre de mots-clés :
   Langage C : Version C99, 32 mots-clés
   C++ : version C98, 63 mots-clés

2. Fichier source :
   Suffixe du fichier source C .c, suffixe du fichier source C++ .cpp, si rien n'est donné lors de la création du fichier source, la valeur par défaut est .cpp

3. Définition de la variable ou emplacement de déclaration :
   Le langage C doit être défini sur la première ligne ; C++ ne l'exige pas

4. Fonction :
   (1) Valeur de retour
   En langage C, si une fonction ne le nécessite pas spécifiez un type de valeur de retour, il renvoie le type int par défaut
   En C++, la détection des valeurs de retour de la fonction est plus stricte. Si une fonction ne renvoie pas de valeur, elle doit être spécifiée comme void. (2) Liste de paramètres
   En langage C, si une fonction ne spécifie pas de liste de paramètres, elle peut accepter n'importe quel nombre de paramètres par défaut, mais en C++, en raison d'une détection stricte du type de paramètre, les fonctions sans liste de paramètres sont par défaut ; void et n’accepte aucun paramètre.
   

5. Paramètres par défaut : Les paramètres par défaut spécifient une valeur par défaut pour les paramètres de la fonction lors de la déclaration ou de la définition d'une fonction. Lors de l'appel de cette fonction, si aucun paramètre réel n'est spécifié, la valeur par défaut est utilisée ; sinon, les paramètres réels spécifiés sont utilisés.
   

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

(1) Tous les paramètres par défaut : Donner toutes les valeurs par défaut de tous les paramètres //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) Paramètres semi-par défaut : Il est stipulé que la valeur par défaut ne peut être transmise que de droite à gauche //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}

Remarque :

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

Le langage C ne prend pas en charge les paramètres par défaut

Surcharge de fonctions

• La surcharge de fonctions fait référence à la déclaration de plusieurs fonctions du même nom avec des fonctions similaires dans la même portée. Les listes de paramètres formels (nombre, type, ordre des types) des fonctions portant le même nom doivent être différentes.

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

• Juste le type de la valeur de retour est différent, ce qui ne peut pas constituer une surcharge de fonction.

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

• La raison pour laquelle C++ prend en charge la surcharge de fonctions : l'éditeur VS compile le type de paramètres de fonction dans le nom de la fonction en bas, donc l'original nom de la fonction Il a été remplacé par un autre nom unique.

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

• La raison pour laquelle le langage C ne prend pas en charge la surcharge de fonctions : le nouveau nom de fonction généré est toujours le même. Ajoutez simplement _

• En C++, la fonction est compilée selon le style du langage C. Ajoutez simplement

  extern "c" avant le nom de la fonction<🎜. >

Citation

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

Il existe deux méthodes pour passer des paramètres aux fonctions en langage C :

passage par valeur

et passage par adresse

Passage par valeur

 : Pendant le processus d'appel de fonction, une variable temporaire sera générée et remplacée par un paramètre formel, et enfin la valeur du paramètre réel sera transmise au temporaire nouvellement alloué variable, c'est-à-dire le paramètre formel. Avantages du passage par valeur
 : Les effets secondaires de la fonction n'affecteront pas les paramètres externes. Inconvénients du passage par valeur
 : Les paramètres externes ne peuvent pas être modifiés en modifiant les paramètres.

Passer la référence

 : Pendant le processus d'appel de fonction, une variable temporaire sera générée et remplacée par des paramètres formels, et enfin l'adresse du paramètre réel sera transmise à la variable temporaire nouvellement allouée . Avantages du passage du doigt
 : gain de place, haute efficacité, la modification des paramètres peut modifier les paramètres réels externes. Inconvénients du passage de pointeurs
 : Les pointeurs ne sont pas sûrs et les effets secondaires des fonctions affecteront les paramètres externes réels.

en C++ :

Référence :

(1) Concept : La référence ne consiste pas à définir une nouvelle variable, mais à une variable existante variable Après avoir pris un alias, le compilateur n'allouera pas d'espace mémoire pour la variable de référence. Il partage le même espace mémoire avec sa variable de référence. (2) Forme :
type et nom de la variable de référence = entité de référence

Remarque :

//引用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;
}

(3) Souvent cité

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

(4) Référence du tableau

常引用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是两个不同的实体}

(5) Scénario de référence :

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

a. Utilisez des références comme paramètres de fonctions pour modifier les paramètres réels.

b. Utiliser des variables de référence comme valeurs de retour des fonctions //Code

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);
}

Comparaison de l'efficacité du passage par valeur, du passage par référence et de la référence

情形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;
}
注意：不能返回栈空间上的引用

//比较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);
}//此代码检测出传值最慢，而传址和引用速度快且用时差不多相同

Quelle est la différence entre une référence et un pointeur ?

Mêmes points :

Contenu de la liste
La méthode de traitement sous-jacente est la même, toutes basées sur des pointeurs . réalisé.
Le type du pointeur sous-jacent correspondant à la variable de référence :
Le type de la variable de référence entité * const
Différences :

Les références doivent être initialisées ; les pointeurs ne sont pas requis.
Un pointeur d'un type commun peut pointer vers n'importe quel objet du même type à tout moment ; une fois qu'une référence fait référence à une entité, elle ne peut pas faire référence à d'autres entités.
Pointeur++ : pointe vers l'adresse suivante ; référence++ : donne la valeur numérique++.
a des significations différentes dans sizeof : le résultat de la référence est la taille du type de référence et le pointeur est toujours l'adresse * le nombre d'octets occupés par l'espace ;
Les pointeurs doivent être adressés manuellement ; les références sont adressées par le compilateur.

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

命名空间

在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++视频教程

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!