Eighth C++基础之C++与C语言的区别及细节_c c++区别ihhhih

原文链接（点击原文链接获取更多学习干货）：

http://blog.bools.cn/archives/1335

C语言与C++

在之前学习当中，我们知道C语言是面向过程的，而C++是面向对象的。

C++面向对象的三大特性，封装、继承、多态。

1.C++的输出打印和头文件的不同

在C++当中，一般用#include<iostream>进行输入输出的头文件，而使用其他头文件时，比如<time.h>，在C++中一般写成<ctime>，就是在头文件关键词前面加c

示范：

#include<iostream>
#define _CRT_SECURE_NO_WARNINGS
using namespace std;
int main()
{
    cout << "我就试一试c++" << ",看看和C语言的区别" << endl;
    system("pause");//堵塞功能
	return 0;
}

"::"双冒号作用：双冒号作用域运算符，就是将变量或者运算符的作用域扩大，一般和namespace一块用。

2.namespace的使用

namespace命名空间的主要用途是解决命名冲突问题，而namespace就是命名一个空间，或者我们理解为打开一个房间。而

using namespace std;

一般在命名在全局变量当中，就是打开std这个房间，因为打开这个房间，cout和endl才能用。

namespace schoolA
{
	int number = 20;
	char name[20] = "foda";
}
int main()
{
	using namespace schoolA;
	cout << number << endl << name << endl;
 
	//cout << schoolA::number << endl << schoolB::name << endl;//或者在变量前声明哪个空间
}

namespace的基本使用，一般是用using namespace 空间名后，可以使用。

namespace的特点：

1.命名空间下可以放变量，函数，结构体，类

void schoolA::test()
{
	cout << "schoolA的名字是：" << schoolA::name << endl;
}
namespace schoolA
{
	int sumnumber = 2000;
	char name[20] = "foda";
	//void test(){cout << "schoolA的名字是：" << schoolA::name << endl;}//直接在namespace中定义函数
	void test();
	struct A{int number = 30;};//在namespace中直接定义结构体
	struct A;
}
int main()
{
	//using namespace schoolA;
	schoolA::test();
	cout << schoolA::sumnumber << endl << schoolB::name << endl;
	cout << schoolB::classA::number << endl;
}

空间包含函数和结构体时，函数和结构体可以直接在定义中定义，函数可以在外部定义，结构体建议在内部定义，不过函数定义时要“::”双冒号是哪个空间的函数和结构体。

2.命名空间必须定义在全局作用域下

namespace schoolA
{
	int number = 20;
	char name[20] = "foda";
}
int main()
{
	using namespace schoolA;
	cout << number << endl << name << endl;
 
	//cout << schoolA::number << endl << schoolB::name << endl;//或者在变量前声明哪个空间
}

3.命名空间可以嵌套命名空间

namespace schoolB
{
	int number = 40;
	char name[20] = "zhongda";
	namespace classA
	{
		int number = 34;
	}
}
	cout << schoolB::classA::number << endl;

4，命名空间是开放的，可以随时往命名空间中添加内容

namespace schoolB
{
	int number = 40;
	char name[20] = "zhongda";
	namespace classA
	{
		int number = 34;
	}
}
namespace schoolB
{
	int level = 3;
}

同名的空间可以合并。

可以起别名

	namespace schoolfoda = schoolA;
	cout << "schoolfoda的名字是" << schoolfoda::name << endl;

这里需要注意：在使用多个房间后，需要标明是哪个房间 

3.using的声明和编译指令

	using schoolC::number;//声明
	using namespace schoolC;//编译指令

用using声明的话，需要注意避免二义性问题

二义性就是写了using声明之后，但编译器又有就近原则

	using schoolC::number;//声明
	using namespace schoolC;//编译指令
	cout << number << endl;

二义性会使编译出错

4.C++比C语言增强的点

1.全局变量检测增加

int a;
int a=10;//出错

全局变量只能定义一次。 

2.函数检测增强，参数类型增强，返回值类型增强，函数调用参数检测增强

定义函数时，被调用函数要表明参数，返回值等

int func(int a, int b)
{
	return (a + b);
}

3.类型转换检测增强

char* p=(char*)malloc(sizeof(char));

类型必须转换成同类型的

4.struct增强

C++中的struct可以添加函数成员

struct classA
{
	int func(int a, int b)
	{
		return (a + b);
	}
	int number = 20;
};

而且使用的时候可以不加struct关键字

	classA one;

5.bool类型增强，C语言中没有bool类型

bool类型只有真假，非0就是真，0为假，非0的值转为一。

bool flage=true;//1

6.三目运算符增强（重点）

在C语言当中，三目运算符返回的是一个值，而C++当中返回的是一个变量。

	int a = 20;
	int b = 30;
	cout << b << endl;//30
	a > b ? a : b = 50;
	cout << b << endl;//50

 7.C++中const增强

在C语言中，const修饰的是伪常量，而在C++中，const修饰的真常量，不可改变的，和#define有异曲同工之妙，所以，建议在后面的代码编译中，定义宏定义常量时，建议用const

	const int c = 40;
	int* p = (int*)&c;
	*p = 50;
	cout << *p << endl << c << endl;

const在C语言中是外部链接，C++中默认const是内部链接

就是说， const定义的变量在同一项目其他文件中，能用，C++中const只能在本文件中用

8.const分配内存情况

1.const分配内存，取地址会分配临时内存

	const int c = 40;
	int* p = (int*)&c;//会分配临时内存

2.extern编译器也会给const变量分配内存

3.用普通变量初始化const变量

	const int c = 40;
	int* p = (int*)&c;
	*p = 50;
	cout << *p << endl << c << endl;

4.自定义数据类型加const也会分配内存的

	const classA two;
	classA* pp = (classA*)&two;//自定义类型的变量，取地址之后会分配内存
	pp->score = 89;
	cout << "classA的分数是：" << pp->score << endl;

5.引用

引用就是取别名

int a=20;
int &b=a;

a的别名就是b。

2.引用必须初始化

int a=20;
int &b;//error
int &b=a;

3.对数组建立引用

    int arr[10];
    int(&parr)[10]=arr;
    for(int i=0;i<10;i++)
    {     
        cout<<parr[i]=i<<endl;
    }
    cout<<endl;

4.引用其实就是利用起别名，操控空间

引用必须引用一块合法的内存空间

不要返回局部变量的引用

引用的原理

引用其实也会取到地址，所以用引用来当函数参数的话，会改变实参

void swap1(int& a, int& b)
{
	int temp=a;
	a = b;
	b = temp;
 
}
int main()
{
	int a = 20;
	int b = 30;
	swap1(a, b);
	cout << a <<"    "<< b << endl;
	int c = 10, d = 40;
	swap1(c, d);
	cout << c  <<"    " << d << endl;
}

 引用做返回数值

引用做返回值时，函数可以直接当成变量

int& try1()
{
	int e = 20;
	return e;//那么e和try1()同名
}
int main()
{
 
	int& ret = try1();//
	cout << ret << endl;//20
	cout << ret << endl;//乱码
}

想要多次使用引用的返回值，要将e设置成静态变量

int& try1()
{
	static int e = 20;
	return e;//那么e和try1()同名
}
int main()
{
	int& ret = try1();
	cout << ret << endl;	
	cout << ret << endl;
	try1()=2000;//相当于e=2000；
	cout << try() << endl;//2000
}

一般来说，引用必须要有合法的空间，所以，不能等于常量，不过，const可以让引用等于常量

	int& arr=10;//int* const arr=10'//error
    const int& arr = 10;//原理是int tmp=10；int* const arr=&tmp；
	int* p = (int*)arr;
	*p = 1000;//error
	cout << arr << endl;

经过const修饰的引用，一般当成常量来用，不会被改变，而在调用函数时，想要展示而不想改变实参的话，可以将函数参数用const修饰

void swap1(const int& a, const int& b)
{
	int temp=a;
	a = b;//const修饰后，a和b不可修改
	b = temp;
}