原文链接（点击原文链接获取更多学习干货）：
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;
}
?