从C过渡到C++

## C++基础1：从C过渡到C++

>     C plus plus -- C语言的超级/带Class的C语言
    C++可以完全引用C/C不能直接调用C++

### 案例:输出Hello World

* 源代码:`HelloWorld.cpp`
``````
#include <iostream>
using namespace std;
int main(){
    cout << "Hello world" << endl;
}
``````
* 编译:`g++ HelloWorld.cpp -o HelloWorld`
* 运行:`./HelloWorld`
* 结果:`Hello world`

从`HelloWorld.cpp`,看C++与C的基本区别:
1. 文件后缀`.cpp`
2. 头文件`#include <iostream>`
3. 命名空间 `using namespace std;`
4. 标准输出`cout`、输出运算符`<<`、换行`endl`
5. 编译工具`g++`

> `g++`安装:`yum install gcc-c++`

---

#### 1.源文件后缀

* C/C++后缀名区别

|C|C++|
|:-|:-|
|`*.c`|`*.cpp` `*.cc` `*.cxx`|

* 不同编译器C++后缀名区别

|平台|可用后缀名|
|:-|
|Unix|`*.C`, `*.cc`, `*.cxx`, `*.c`|
|GNU C++|`*.C`, `*.cc`, `*.cxx`, `*.cpp`, `*.c++`|
|Borland C++|`*.cpp`|
|Microsoft Visual C++|`*.cpp`, `*.cxx`, `*.cc`|

---

#### 2.引用头文件

C++头文件使用C标准库,在C标准库文件名前加上字母`c`，并且省略后缀名`.h`，例如:

|C|C++|
|:-|:-|
|`#include <stdio.h>`|`#include <iosteam>` /`#include <cstdio>`|
|`#include <stdlib.h>`|`#include <cstdlib>`|
|`#include <string.h>`|`#include <cstring>`|
|`#include <math.h>`|`#include <cmath>`|

*有些C++编译器同时支持以上两种头文件，但有些不。请使用C++标准方式*

---

#### 3.函数重载(overload)  

实验:以下C与C++的编译执行结果
* `printf.c`
```
#include <stdio.h>
void printf(){
    printf("Hello world");
}
int main(){
    printf();
}
```
gcc printf.c -o print
print.c:3:6: error: conflicting types for ‘printf’
 void printf(){

* `printf.cpp`
```
#include <cstdio>
void printf(){
    printf("Hello world");
}
int main(){
    printf();
}
```
编译运行成功

函数重载:函数名相同只有参数(个数或者类型)不相同。

|C|C++|
|:-|:-|
|不支持重载|支持重载|

---

#### 4. 命名空间 

实验:以下C的编译结果
* `scope.c`
```
#include <stdio.h>
void test(){
    printf("this is test\n");
}
void test(){
    printf("this is another test\n");
}
int main(){
    test();
}
```
gcc scope.c -o scope
scope.c:9:6: error: redefinition of ‘test’
 void test(){
      ^
scope.c:3:6: note: previous definition of ‘test’ was here
 void test(){

作用域

|C|C++|
|:-|:-|
|文件、函数、复合语句|命名空间、文件、类作用域、函数、复合语句|

命名空间

|C|C++|
|:-|:-|
|不支持命名空间|支持命名空间|

* 命名空间的作用:避免全局变量、函数、类的命名冲突(因为名字相同而编译失败)

* 定义命名空间
``````
namespace 空间名 {

}
``````
* 引用命名空间
``````
using namespace 空间名;
``````
* 标准命名空间`std`
``````
using namespace std;
``````

C++命名空间处理方式
``````
#include <cstdio>
namespace scope1 {
        void test(){
            printf("this is test\n");
        }
}
namespace scope2{
void test(){
        printf("this is another test\n");
    }
}
int main(){
    scope1::test();
    scope2::test();
}
```

* 命名空间嵌套
```
namespace A {
  void test1();
  namespace B {
    void test2();
    namespace C {
      void test3();
    }
  }
}
```

在命名空间`A`外访问
```
A::test1();
A::B::test2();
A::B::C::test3();
```

在命名空间`A`内访问
```
test1();
B::test2();
B::C::test3();
```

在命名空间`B`内访问
```
test1();
test2();
C::test3();
```

在命名空间`C`内访问
```
test1();
test2();
test3();
```

```
namespace A {
  void test();
  namespace B {
    void test();
    namespace C {
      void test();
    }
  }
}
```

在命名空间`A`外访问
```
A::test();
A::B::test();
A::B::C::test();
```

在命名空间`A`内访问
```
test();
B::test();
B::C::test();
```

在命名空间`B`内访问
```
test();
C::test();
```

在命名空间`C`内访问
```
test();
```

> 命名空间可以嵌套，类定义是否嵌套？结构体/联合体定义是否可以嵌套？函数定义是否可以嵌套？复合语句(if-else for while do-while)是否可以嵌套？

```
class A{
    class B{
    };
}
```

```
void test1(){
    int test2(){
    }
}
```

* 命名空间可以重复定义

```
namespace A{
  void test1();
  // ...
}

namespace A{
  void test2();
  // ...
}
```

全局命名空间/默认命名空间/匿名命名空间:所有没有定义命名空间的函数都在全局命名空间内。
比如: main()函数，使用<stdio.h>。

命名空间没有生存周期，作用域是全局。

命名空间可以限制所有标识符(变量名、函数名、类名、空间名、类型名(typedef)),宏定义不受命名空间限制。

---

#### 5. 类型 

* 新增基本类型`bool`--`true`/`false`
 * `password.c`
```
#include <stdio.h>
int main(){
      printf("input user name:");
      char name[BUFSIZ];
      scanf("%s",name);
      printf("input 3 number password:");
      int password1;
      scanf("%d",&password1);
      printf("input 3 number password again:");
      int password2;
      scanf("%d",&password2);
      printf("password check:%d\n", password1 == password2);　　//ture:1;false:0;
}
```
 * `password.cpp`
```
#include <iostream>
#include <cstdio>
using std::cout;
using std::cin;
using std::endl;
int main(){
      cout << "input user name:";
      char name[BUFSIZ];
      cin >> name;
      cout << "input 3 number password:";
      int password1;
      cin >> password1;
      cout << "input 3 number password again:";
      int password2;
      cin >> password2;
      cout << "password check:" << (password1 == password2) << endl;
}
```

* 新增自定义类型`class`
详细信息参见：类与对象章节

* C++的新增关键`and` `or` `not`

```
if(a>b && c<d){

}
```

```
if(a>b and c<d){

}
```

在C语言中`iso646.h`定义了这些宏定义。

---

#### 6. 思想

|C|C++|
|:-|:-|
|面向过程|面向对象/基于对象、模板/泛型编程|

何为面向过程？何为面向对象？
* 面向过程：强调如何处理，通常是自下而上。
* 面向对象：强调执行处理的对象，通常是自上而下。

> 面向过程与面向过程、厨师与老板

#### 7. 动态内存

* 基本类型的动态内存
 * `dynamic_mem.c`
```
#include <stdio.h>
#include <stdlib.h>
int main(){
      int* num = malloc(sizeof(int));
      *num = 100;
      printf("%d\n",*num);
      free(num);
}
```
 * `dynamic_mem.cpp`
```
#include <iostream>
int main(){
      int* num = new int;
      *num = 100;
      std::cout << *num << std::endl;
      delete num;
}
```

标量：单个值(基本类型(int、float、char)/复合类型(数组、指针、引用))/向量：多个值(类、结构体、联合体等)

> `new` `delete`都是关键字，用于申请/释放堆内存。

动态内存区别

|C|C++|
|:-|:-|
|`malloc()`/`free()`|`new`/`delete`|

*C++仍然可以使用`malloc()`/`free()`，但是不建议这么做。*

问题：
* `malloc()`申请内存，是否可以使用`delete`销毁内存？
* `new`申请内存，是否可以使用`free()`销毁内存？
答:不能，malloc /free主要为了兼容C，new和delete 完全可以取代malloc /free的。malloc /free的操作对象都是必须明确大小的。而且不能用在动态类上。new 和delete会自动进行类型检查和大小，malloc/free不能执行构造函数与析构函数，所以动态对象它是不行的。当然从理论上说使用malloc申请的内存是可以通过delete释放的。不过一般不这样写的。而且也不能保证每个C++的运行时都能正常。

> 注意：`delete`和`free()`动态内存后，指针指向`NULL`