Ce que les programmeurs débutants doivent savoir sur la différence entre le langage C et le C++

Le langage C que les programmeurs débutants devraient connaître La différence entre C++ et C++

Lorsque vous apprenez la programmation pour la première fois, beaucoup de gens pensent que le langage C et le C++ sont identiques ? Aujourd'hui, je vais présenter en détail les différences entre le langage C et le C++. Apprenons ensemble.

1. Mots-clés

Les marques bleues sont des mots-clés du langage C. C++ hérite de tous les mots-clés du langage C. Les marques rouges suivantes sont des mots-clés C++ que le langage contient. pas (selon c++98, C++ contient 63 mots-clés)

2. Différences entre les fichiers source
Suffixe du fichier du langage C Le suffixe du nom de fichier d'origine. pour .c et c++ est .cpp
Si rien n'est donné lors de la création du fichier source, la valeur par défaut est .cpp
3 La valeur de retour est différente
En langage C, si une fonction ne spécifie pas de. return Type de valeur, la valeur par défaut est de type int et renvoie un nombre aléatoire, généralement 0XCCCCCCCC
En C++, si la fonction ne renvoie pas de valeur, elle doit être spécifiée comme type void, sinon la compilation ne passera pas
4. Liste de paramètres
En langage C, lorsqu'une fonction n'a pas de liste de paramètres spécifiée, elle peut accepter n'importe quel nombre de paramètres par défaut
En C++, il existe une détection stricte du type de paramètre. Une fonction sans paramètre. La liste est par défaut annulée et ne reçoit aucun paramètre.
Paramètres par défaut
Les paramètres par défaut sont des paramètres de fonction qui spécifient une valeur par défaut lorsqu'ils sont déclarés et définis. Lors de l'appel de cette fonction, si aucun argument n'est spécifié, les valeurs par défaut sont utilisées, sinon les arguments spécifiés sont utilisés.
Le code suivant :

#include<iostream>using namespace std;void test(int a = 1)
{    cout << a << endl;
}int main()
{
    test();
    test(10);//输出的结果是1
    return 0;//函数输出结果是10}

Les paramètres par défaut sont divisés en deux catégories, l'une est complète par défaut et l'autre est semi-par défaut.
Le premier est celui par défaut complet. Tous les paramètres des paramètres par défaut complets ont des valeurs par défaut. Si aucun paramètre n'est transmis manuellement, le compilateur utilisera les paramètres de la liste des paramètres par défaut. Mais il convient de noter ici que si seuls certains paramètres sont transmis lors du passage des paramètres, la valeur correspondra de gauche à droite.
Exemple de code :

#include<iostream>using namespace std;void test(int a = 1,int b = 2, int c = 3)
{    cout << a << " " << b << " " << c << endl;
}int main()
{
    test();//1 2 3
    test(10);//10 2 3
    test(10, 20);//10 20 3
    test(10, 20, 30);//10 20 30
    return 0;
}

Démonstration du code de paramètre semi-par défaut :

void test(int a ,int b = 2, int c = 3)
{    cout << a << " " << b << " " << c << endl;
}void test1(int a, int b, int c = 3)
{    cout << a << " " << b << " " << c << endl;
}

La fonction de test passe au moins un paramètre, et le Fonction test1 au moins Ce n'est qu'en passant deux paramètres que la fonction peut fonctionner normalement.

Remarque :
Les paramètres avec des valeurs par défaut doivent être placés à la fin de la liste des paramètres. Parce que les paramètres sont transmis de droite à gauche.
Les paramètres par défaut ne peuvent pas apparaître à la fois dans la déclaration et la définition de la fonction, un seul d'entre eux peut être laissé.
La valeur par défaut doit être une constante ou une
variable globale.
Le langage C ne prend pas en charge les valeurs par défaut.
5. C++ prend en charge la surcharge de fonctions, mais pas le langage C.
Dans le développement réel, nous devons parfois implémenter plusieurs fonctions avec des fonctions similaires, mais certains détails sont différents. Par exemple, si nous voulons échanger les valeurs de deux variables qui ont plusieurs types, tels que int, float, char, bool, etc., nous devons transmettre l'adresse de la variable dans la fonction via des paramètres. En langage C, les programmeurs doivent souvent concevoir trois fonctions avec des noms différents, et leurs prototypes de fonctions sont similaires aux suivants :

void swap1(int *a, int *b); //交换 int 变量的值
void swap2(float *a, float *b); //交换 float 变量的值
void swap3(char *a, char *b); //交换 char 变量的值
void swap4(bool *a, bool *b); //交换 bool 变量的值

Mais en C++, cela est complètement inutile. C++ permet à plusieurs fonctions d'avoir le même nom, tant que leurs listes de paramètres sont différentes. Il s'agit d'une surcharge de fonctions (Function Overloading). Avec la surcharge, un nom de fonction peut être utilisé à plusieurs fins.

La liste des paramètres est également appelée signature des paramètres, comprenant le type de paramètre, le nombre de paramètres et l'ordre des paramètres. Tant qu'il y a une différence, elle est appelée une liste de paramètres différente.

#include <iostream>using namespace std;//交换 int 变量的值void Swap(int *a, int *b){int temp = *a;
*a = *b;
*b = temp;
}//交换 float 变量的值void Swap(float *a, float *b){float temp = *a;
*a = *b;
*b = temp;
}//交换 char 变量的值void Swap(char *a, char *b){char temp = *a;
*a = *b;
*b = temp;
}//交换 bool 变量的值void Swap(bool *a, bool *b){char temp = *a;
*a = *b;
*b = temp;
}int main(){//交换 int 变量的值int n1 = 100, n2 = 200;
Swap(&n1, &n2);cout<<n1<<", "<<n2<<endl;//交换 float 变量的值float f1 = 12.5, f2 = 56.93;
Swap(&f1, &f2);cout<<f1<<", "<<f2<<endl;//交换 char 变量的值char c1 = &#39;A&#39;, c2 = &#39;B&#39;;
Swap(&c1, &c2);cout<<c1<<", "<<c2<<endl;//交换 bool 变量的值bool b1 = false, b2 = true;
Swap(&b1, &b2);cout<<b1<<", "<<b2<<endl;return 0;
}

Résultat de l'exécution :

200, 100 
56.93, 12.5 
B, A 
1, 0

La surcharge est dans la même portée (même classe, même espace de noms, etc.) a plusieurs fonctions avec le même nom mais des paramètres différents. Le résultat de la surcharge est qu'un nom de fonction a de multiples utilisations, ce qui rend la dénomination plus pratique (dans les projets de taille moyenne et grande, nommer les variables, les fonctions et les classes est un problème épineux) et l'appel plus flexible.

Lors de l'utilisation de fonctions surchargées, les fonctions des fonctions portant le même nom doivent être identiques ou similaires. N'utilisez pas le même nom de fonction pour implémenter des fonctions complètement indépendantes. Bien que le programme puisse s'exécuter, la lisibilité n'est pas. bon et rend les gens confus.
Notez que différentes listes de paramètres incluent différents numéros, types ou ordres de paramètres. Il n'est pas acceptable d'avoir simplement des noms de paramètres différents. Les valeurs de retour des fonctions ne peuvent pas être utilisées comme base pour une surcharge.

Règles de surcharge des fonctions :

(1) Les noms de fonctions doivent être les mêmes.

(2) Les types de retour des fonctions peuvent être identiques ou différents.

（3）仅仅返回类型不同不足以成为函数的重载。
6、指针和引用
C语言中函数传参方式有两种：传值和传址
以传值方式，在函数调用过程中会生成一份临时变量用形参代替，最终把实参的值传递给新分配的临时形参。它的优点是避免了函数调用的副作用，却无法改变形参的值。如果要改变实参的值，只能通过指针传递。
指针可以解决问题，但是不安全，因此在C++中引入了引用。
引用：引用不是新定义的一个变量，他是原变量的一个别名，编译器不会为引用变量开辟空间，它和他引用的变量共用同一块内存空间。
类型& 变量（对象名）=引用变量
int &num1=num0；
引用特性;：
（1）引用定义时必须初始化
（2）一个变量可以有多个引用
（3）引用一旦绑定一个实体就不能改变为其他变量的引用
//指针和引用的区别
引用不可以为空，但指针可以为空
引用不可以改变指向，对一个对象”至死不渝”；但是指针可以改变指向，而指向其它对象
引用的大小是所指向的变量的大小，因为引用只是一个别名而已；指针是指针本身的大小，4个字节。

7、命名空间
在C++中，变量、函数和类都是大量存在的，这些变量、函数和类的名称将都存在于全局命名空间中，会导致很多冲突，使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或者名字污染，namespace关键字的出现就是解决这种问题。而C语言中没有。
8、输入与输出
cout代表c++的输出流
cin代表c++的输入流
它们都是在头文件“iostream”中定义。
“cout”必须与”<<”一起使用，“<<”起到插入的作用。
在一条语句中可以多次使用“<<”输出多个数据。
如：cout<

#include <iostream>using namespace std;int main()
{int a,b;cout<<"请输入a，b的值"<<endl;cin>>a>>b;cout<<"输出a的值"<<a<<"输出b的值"<<b<<endl;return 0;
}

感谢大家的阅读，大家现在知道C语言和C++的区别了吗？                                  

本文转自：https://blog.csdn.net/qq_39539470/article/details/81268916

推荐教程：《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!