1、c++区别与java的一个地方：C++更多的是一种规范，不同时期的不同标准，提供了不同的语法要求。所以各个厂商在对C++的支持上也做得不尽相同，比如有些语法vs就支持gcc
就支持的差一些，而某些语法gcc支持，在vs上编译就通不过。Java除了语言之外更有一种产品的概念，所以支持规范都向下兼容，保证了更好的跨平台性。这是要指出的一个地方，所以我们可以发现C++11，C++98等等标准。
2、volatile 关键字。比如我们有可能写这样一个语句：
Int a = 3;
a+= 4;
a+= 5;
对于智能的编译器来讲，开始+=4，后来+=5，这种操作是可以合并的。
如果加上了volatile关键字：
Volatile int a = 3;
a + = 4;
a + = 5;
编译器就不再对该段代码进行优化。严格分步执行。
//详情参见：http://www.cnblogs.com/yc_sunniwell/archive/2010/07/14/1777432.html 关于volatile的描述。
3、还有一些马上就会常见的关键字：是在c中没有的概念：
比如bool，class，public，private，new，delete。
关于new跟delete的一些写法的注记：
先介绍在C里面的写法：
Int *p = (int *) malloc(sizeof(int));
*p = 10;
Printf(“%d ”,*p);
Free(p);
同样是在堆内开辟空间，malloc需要.h头文件的支持。
而new作为嵌入在C++里面的一个关键字不需要头文件的支持，就可以直接使用。
写法：
Int *p = new int;
*p = 10;
Cout<<p<<endl;
Delete p;
关于创建数组：
Int *p = new int[10];
P[1] = 12;
Cout<<p[1]<<endl;
Delete []p;//这里一定要注意！！！
/*
注意点1:
因为按照创建的套路有可能会写成 delete p，这样就只释放了首地址对应的对内存空间。也就是p[0].
注意点2：
有可能写成：delete p[];
error: expected primary-expression before ']' token
delete p[];
^
他说缺少了一个基本的表达。那我们加上这个10看行不行。
error: type 'int' argument given to 'delete', expected pointer
delete p[10];
^
他说，整形参数被给到了delete，但是期望一个指针。所以这样的写法也是通不过的。
*/
示例代码：
#include <iostream>
using namespace std;
int main()
{
int *p = new int[3];
p[2] = 10;
cout<<p[2]<<endl;
delete []p;
return 0;
}
4、Inline 关键字。内联函数的意思。
Inline是一种建议，当程序代码量比较小的时候，就会把对应的内联函数直接转换成代码放到对应的执行体中，如果代码量过大，作为一种可以优化代码的编译器来讲他就还是以函数调用的方式进行，至于这个代码量和复杂的大小没有明确规定，是程序员的一种感觉。以及编一起的一种操作。所以inline是一种建议，而非必须，就跟之前也有一个关键字寄存器register他不一定被放到寄存器中，只是对编译器的一种建议，带来的代价就是并不能通过取地址方式来得到当前的这个变量。即使编译器没有把他放到寄存器中。
5、引用：
引入：我们知道这样并不能交换a、b的值。
#include <iostream>
using namespace std;
void swap(int a,int b){
int temp = a;
a = b;
b = temp;
}
int main()
{
int a = 1;
int b = 2;
swap(a,b);
cout<<"a = "<<a<<" b = "<<b<<endl;
return 0;
}
可以交换的方式：
指针方式：
#include <iostream>
using namespace std;
void swap(int *a,int *b){
int temp = *a;
*a = *b;
*b = temp;
}
int main()
{
int a = 1;
int b = 2;
swap(a,b);
cout<<"a = "<<a<<" b = "<<b<<endl;
return 0;
}
引用方式：
#include <iostream>
using namespace std;
void swap(int &a1,int &b1){
int temp = a1;
a1 = b1;
b1 = temp;
}
int main()
{
int a = 1;
int b = 2;
swap(a,b);
cout<<"a = "<<a<<" b = "<<b<<endl;
return 0;
}
这里最好画图来描述。然后得到使用引用能提高代码的执行效率。
值得注意的是：
引用必须在声明的时候给出定义，否则这是无效的。
int a = 3;
Int &a1 = a;
这是可以的
但是下面这样写法就不行：
Int a = 3;
Int &a1;
a1 = a;
//这个写法就不行。
这些点是需要注意的。
5、函数，函数重载，缺省函数。
这里主要防止缺省函数带来的二义性。重载这个点还是比较重要的。需要掌握的点就是关于void这个关键字。如果函数参数没有的话在C++里面一定要写上void。而在c里面是不必要写的。这样也能想通，因为在c里面不存在重载这个概念，所以有没有参数，这里要求不是很严格。但是对于c++里面因为存在重载概念，所以有没有参数有什么参数都要写的非常清楚才可以。
模板函数这个要练一下。
#include <iostream>
template <class T>
T myAdd(T a, T b){
return a + b;
}
//int myAdd(int a, int b){
// return a + b;
//}
//double myAdd(double a, double b){
// return a + b;
//}
using namespace std;
int main(){
cout << "hello world" << endl;
cout << myAdd(3, 4) << endl;
cout << myAdd(3.14, 6.58) << endl;
system("pause");
return 0;
}
因为有了重载的概念，所以我们可以做 short char int long float double等等类型的加法，但是，这样我们就要写许许多多的函数，才可以，这样就很繁琐，所以，就出现了这样一个简化的方式，模板函数。只要你是我这个类型的我就能给你做加法。并且你给我什么类型的我就做什么运算。这既是模板函数，当然后面还有更加高级的应用。
6、引用这个东西要再背一下，这些东西要立刻反应不能想太久。
再来做一下swap这个练习。
//给我写的嘛~~~客观扫一眼就好啦~
#include <iostream>
void swap1(int a,int b){
int temp = a;
a = b;
b = temp;
}
void swap2(int *a1, int *b1){
int temp = *a1;
*a1 = *b1;
*b1 = temp;
}
void swap3(int &a1, int &b1){
int temp = a1;
a1 = b1;
b1 = temp;
}
using namespace std;
int main(){
int a1 = 3;
int b1 = 4;
cout << "交换前a1 = " << a1 << "，b1 = " << b1 << endl;
swap1(a1, b1);
cout << "交换后a1 = " << a1 << ", b1 = " << b1 << endl;
swap2(&a1, &b1);
cout << "交换后a1 = " << a1 << ", b1 = " << b1 << endl;
swap3(a1, b1);
cout << "交换后a1 = " << a1 << ", b1 = " << b1 << endl;
system("pause");
return 0;
}
引用作为函数参数，没有出入栈操作，所以效率高。
命名空间的使用。
举例：
#include <iostream>
//如果这里面没有 using namespace std;
namespace letben{
int func(int a, int b){
return a + b;
}
}
namespace instruction{
void instruction(void){
std::cout << "这个怎么说呢，因为叫李飞的人是在太多了，如果只在我家里，大家还可以愉快的叫我李飞 但是放眼全国，一叫李飞，就可能乱套。如果调用李飞.吃饭，那么有男人，有女人，有饭量大有饭量小，导致二义性 所以为了避免这种状况产生，就加了这样一层限定。表示谁里面的什么方法。 " ;
}
}
int main(){
std::cout << "这里是命名空间的使用" << std::endl;
std::cout << letben::func(5, 8) << std::endl;
instruction::instruction();
system("pause");
return 0;
}
类的本质是结构+代码+继承封装多台的机制。