C与C++的六个区别_c和c++scanf不一样吗-CSDN博客

本文链接：https://blog.csdn.net/miaoza/article/details/109298642

C与C++的六个不同

1. output、input

在C与C++中，input、output所使用的符号不同，具体示例如下：

#include <stdio.h>

#include <iostream>
using namespace std;

int main()
{
	int a;
	char ch;
	
	//对于input
	cin>>a>>ch;             //error : cin>>a,ch
	scanf("%d %c",&a,&ch);
	
	//对于output
	printf("%d  %c \n",a,ch);
	cout<<a<<ch<<endl;       //endl表示\n error : cout<<a,ch<<endl;
	
	return 0;
}

总结：

输入流input：在C中使用scanf，在C++中使用cin，两者之间的区别：scanf对数据类型具有严格性，而cin对数据类型无要求；
输出流output：在C中使用printf，在C++中使用cout，两者之间，printf的格式化能力更强，cout使用更为繁琐，因而在C++中更常用printf，例如：

printf("a = %d ch = %c \n ",a,ch);  
 
cout<<"a = "<<a<<"ch = "<<ch<<endl;

在C++中，需要引入C++头文件（此头文件无.h)，及引用命名空间，如下：

#include <iostream>
using namespace std;

cin>>a>>ch：表示先将屏幕中的值赋给a，再将值赋给ch；
cin>>a,ch; cout<<a,ch<<endl; 均属于错误做法；
endl : 表示 "\n；
注意：<< >>中间不能添加空格！

2. 常变量const

定义const常变量时，编译器在编译过程中自动将常变量替换。

#include <stdio.h>

#include <iostream>
using namespace std;
#define PI 3.14      //宏常量
#define MAX 10
enum {LEN = 10};     //枚举常量
const int max = 10;  //常变量

int main()
{
	const int a = 10;
	int b = 0;
	int *p = (int *)&a;   //p指向a的地址
	*p = 100;             //将a的地址的值改为100
	b = a;
	cout<<"a = "<<a<<"b = "<<b<<"*p"<<endl;
	
	return 0;
}

总结

宏变量和常变量的区别：
(1)宏变量在预编译时被替换，常变量在编译时被替换
(2)宏变量不分配空间，常变量分配空间
(3)定义宏变量时无类型要求，定义常变量时检查类型
定义常量时，通常定义常变量const；
C++在编译后，将定义的常变量字符自动替换，而其地址的值则随着改变而改变。

int main()
{
	const int a = 10;
	int b = 0;
	int *p = (int *)&a;
	*p = 100;
	b = 10;
	cout<<"a = "<<10<<"b = "<<b<<"*p"<<endl;
	//即在打印时a被替换为10，而其地址的值随着改变而改变
	return 0;
}

3. 引用

在C++中，具有引用此概念，而C中不具有引用
引用又称作别名，外号
引用表示形式：&c = a；通过下面代码具体描述：

int main()
{
	int a = 10;
	int b = a;
	int &c = a;  //此行表达式表示c是a的引用，两个意义相同，即c的值改变则表示a的值改变，a的值改变则表示c的值改变
	c = 100;     //等同于 a = 100;
	int *p = &c; //等同于int *p = &a;
	return 0;
}

引用的用法：以交换数值为例

void Swap_Int(int *a, int *b)
{
	//通过指针对两个数进行交换
	int tmp = *a; // a = &x; b = &y;
	*a = *b;
	*b = tmp;
}

void Swap_I(int &a,int &b)
{
	//通过引用直接对两个值进行交换
	int tmp = a; // a = x; b = y;
	a = b;
	b = tmp;
}

int main()
{
	int x = 10, y = 20;
	Swap_Int(&x,&y);//通过地址的传递进行值的交换
	Swap_I(x,y);    //通过引用进行值的交换
	return 0;
}

通过交换例子，可以得到：在C中，通过形参间接改变实参的值；而在C++中，通过形参可直接改变实参的值。相比而言，更容易理解，同时指针需要判断是否为空。

总结

&具有三种用法：(1)放在两个变量中间，表示位与运算符；(2)某一变量之前表示取地址；(3)C++中的引用
引用特点：(1)没有空引用；（2)定义引用时必须初始化；(3)没有引用的引用（指针具有二级指针)

int a = 10;
int &b = a;//error : int &b; 引用必须初始化
           //error : int &&x = a; 无二级引用

引用的用法

4. 函数的重载

众所周知，函数是由：函数返回类型、函数名、形参列表以及函数体组成。
那么在C与C++中如何区分函数呢？
在C中，函数是由函数名进行区分；而在C++中，函数是由函数名、形参列表（形参类型、形参个数)进行区分；
因而函数名、形参列表的改变称之为函数的重载
具体示例如下:

//在C中，函数名相同，则无法编译成功
//而在C++中，函数名不同、形参列表不同则编译成功
int Max(int a, int b)
{
	return a>b? a:b;
}
char Max(char a, char b)
{
	return a>b? a:b;
}

double Max(double a, double b)
{
	return a>b? a:b;
}
int main()
{
	int x = Max(12,23);
	char ch = Max('a','x');
	double dx = Max(12.23,34.45);
	return 0;
}

返回类型不能作为函数的重载，例如:

char Max(char a, char b)
{
	return a>b? a:b;
}
/*
double Max(char a, char b)
{
	return a>b? a:b;
}
在C++中，当函数名和形参列表相同，返回类型不同时，无法编译成功，
因为目前还未能成功对返回类型的识别，
因此返回类型不能作为函数重载的依据。
*/
int main()
{
	char ch = Max('a','x');
	return 0;
}

当参数个数不同时，也称作函数的重载，如下：

double Max(double a, double b)
{
	return a>b? a:b;
}
/*
double Max(double a, double b，double c)
{
	return Max(a,Max(b,c));
}
*/
int main()
{
	double dx = Max(12.23,34.45);
	double dx = Max(12.23,34.45,45.56);
	return 0;
}

5. 形参可否带有默认值

在C中，定义函数时，形参不能带有默认值；而在C++中，形参可以带有默认值。
具体规则如下：
在定义函数时，形参的默认值：从右向左依此给值，不可跳跃
而在调动函数时，实参的规则：从左向右依此给值，不可跳跃

void fun(int a,int b = 0,int c = 0,int d = 0,int e = 0)
{}
/* error:
void fun(int a,int b = 0,int c,int d = 0,int e = 0)
{}
*/
int main()
{
	fun(12,23);//error : fun(12,,23);
	fun(12,23,34); //a = 12; b = 23; c = 34;
	return 0;
}

注意：以上两种错误写法！！
对于参数是指针形式也可进行带默认值：NULL或者强转；具体规则相同

void fun(int *a,int *b = NULL)
{}
void fun(int *p,int *s = (int *)0x0009)
{}
/*error : 指向地址
void fun(int *a,int *b = 0x0009)
{}
*/

6. new与delete

在堆区(.heap)开辟及释放空间时，
C：malloc开辟空间，free释放空间；
C++：new开辟空间，delete释放空间。
具体示例如下:

int main()
{
	int n;
	cin>>n;
	//C与C++申请开辟空间
	int *p = (int *)malloc(sizeof(int));
	*p = 100;

	int *s = new int;
	//int *s = new int(10);
	
	//C与C++释放空间
	free(p); p = NULL;
	delete s; s = NULL;
	
	return 0;
}

总结：new：在申请开辟空间的时候，可以直接赋值，而malloc只能开辟空间；

对于开辟n个空间：new可以在申请空间的同时直接对每一个空间进行初始化，及释放多个空间

int main()
{
	int n = 10;
	int *p = (int *)malloc(sizeof(int)*n);
	int *s = new int[n](10); //vs 2019 ; c99可直接初始化
	free(p); p = NULL;
	delete []s;              //注意格式的书写
	return 0;
}