C++程序设计

　　结果如下：

函数内部的a：100函数内部的b：40主函数的a：15主函数的b：20

可以看到： 在函数内部修改了传进来的参数，只是修改了clone版本，并没有修改真正的a和b。 这也就是传值调用。

在C++的函数中，我们也可以使用 参数的默认值，即如果传入了该参数，那么就是用； 如果没有传入，就是用默认值，如下所示：

int sum(int a, int b=20){  int result;  result = a + b;    return (result);}

14. C++中的数字运算

　　我们可以引入 cmath库，然后使用C++自带的数字运算的函数，举例如下:　

#include #include using namespace std;int main(){int a = -10;double b = 4.54;float c = 45.2;cout << abs(a) << endl << sqrt(b) <
　　注意：这里必须引用 cmath库，即 #include  然后就可以使用诸如 sqrt() abs() pow() floor() sin() cos() tan()之类的函数了。
15. 数组
　　在C++中声明数组的方法很简单，即：
int numbers[10];
　　其中int也可以换成其他你需要的类型，如 double等 。 在变量名后面的数字一定要大于0，这里为10表示这个数组中可以放下长度为10的数。
　　 我们还可以初始化数组，只是这里初始化数组使用的是{}，在数组的定义和初始化方面C++和js的差别较大。如下所示：
　　
#include 
using namespace std;
int main()
{
int numbers[8] = {45, 12, 85, 56};
cout << numbers[0] << endl<< numbers[1] << endl<< numbers[2] << endl<< numbers[3] << endl;
}
　　最终的输出结果： 45， 12， 85， 56
　　我们也可以不限制数组的长度： 如 int numbers[] = {45, 12, 85, 56};
16. C++字符串
　　在C++中，由于字符串的特殊性，一般情况下，我们是需要单独来将字符串的。在C++中有两种方式表示，一种是引入的C语言风格的，另一种是C++特有的。
　char str[] = {'h', 'e', 'l', 'l','o', '\0'};
　　字符串实际上是使用 null 字符 '\0' 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。 可以看出，这里字符串的写法与数组非常相似。
　　还可以写成下面这种形式：
　　char str[] = "hello";
上面两种方式的字符串的效果是一样的。
　　最终的存储形式就是这样，最后一位是使用null占位表示结束。
　　在C++中，有大量的处理字符串的内置函数，如果希望使用这样函数，需要引入cstring（正如数学运算引入了cmath一样）举例如下所示：
#include #include using namespace std;int main() {    char str1[] = "zhuzhenwei";    char str2[] = "hetingting";    cout << strlen(str1) << endl << strlen(str2) << endl;    cout << strcat(str1, str2) << endl;}
　 最终输出：10 10 zhuzhenweihetingting
　　上面所说的都是C语言中字符串的实现，下面的是C++的。
　　C++ 标准库提供了 string 类类型，支持上述所有的操作，另外还增加了其他更多的功能。
　　看下面的例子:
#include #include using namespace std;int main (){   string str1 = "Hello";   string str2 = "World";   string str3;   int  len ;   // 复制 str1 到 str3   str3 = str1;   cout << "str3 : " << str3 << endl;   // 连接 str1 和 str2   str3 = str1 + str2;   cout << "str1 + str2 : " << str3 << endl;   // 连接后，str3 的总长度   len = str3.size();   cout << "str3.size() :  " << len << endl;   return 0;}
　　值得注意的是： 这里引入的是：#include  而不再是 #include , 两者的区别在哪呢？
　　显然，cstring是c语言中的string，而string就是C++中类string，所以这里我们用到了链式调用，可以看出面向对象的C++使用起来多么方便，如果js也可以这样随便引入，就太好了。
17. C++指针
　　C++中比较有特色的当然就是指针了。这也是我复习C++的一个理由~ 看完这个就要睡觉啦~ 好困啊
　　哈哈，让我们先来看一看教程的说法：
学习 C++ 的指针既简单又有趣。通过指针，可以简化一些 C++ 编程任务的执行，还有一些任务，如动态内存分配，没有指针是无法执行的。所以，想要成为一名优秀的 C++ 程序员，学习指针是很有必要的。
　　恩，加油吧，捡起来这一部分内容，先看看下面的代码：
#include using namespace std;int main (){   int  var1;   char var2[10];   cout << "var1 变量的地址： ";   cout << &var1 << endl;   cout << "var2 变量的地址： ";   cout << &var2 << endl;   return 0;}
　　这和之前的有什么区别的？ 恩，就是多了个&， 这在C++中是用来取地址的，即你这个变量住在哪？（变量的内存地址） 看看输出的结果：
var1 变量的地址： 0x7fff9d7403ec
var2 变量的地址： 0x7fff9d7403f0
　　0X是指16进制的数字。
　　那么什么是指针呢？
　　指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。声明指针的方式如下：
type *name;
　　如 int *p; 这里就声明了一个p指针，注意：这里带有*, 是说我声明了一个指针，但是并不是说*p是指针，因为p才是真正的指针，而*p是指这个p指针所指向地址的值。 *和指针是密切相关的。如下面的声明方式都是有效的指针声明：
int    *ip;    /* 一个整型的指针 */double *dp;    /* 一个 double 型的指针 */float  *fp;    /* 一个浮点型的指针 */char   *ch     /* 一个字符型的指针 */
　　看看这个在C++中使用指针的例子：
#include using namespace std;int main (){   int  var = 20;   // 实际变量的声明   int  *ip;        // 指针变量的声明   ip = &var;       // 在指针变量中存储 var 的地址，因为指针的值是地址！！！！！！！！！！ 而&var 就是在取变量var 的地址。   cout << "Value of var variable: ";   cout << var << endl;   // 输出在指针变量中存储的地址   cout << "Address stored in ip variable: ";   cout << ip << endl;   // 访问指针中地址的值   cout << "Value of *ip variable: ";   cout << *ip << endl; // 这里ip是指针，它的值就是地址，而*ip是地址所在的值，故最终是20   return 0;}
　　结果如下：
Value of var variable: 20
Address stored in ip variable: 0x7fff99a46294
Value of *ip variable: 20
　　
18. C++引用
　　引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。
　 首先需要明白的是：引用不同于指针。　　
　　
　　通俗的讲（个人理解），引用就是一个人的小名。看，比如指明了我这个大名：
int zzw = 8;
　　即8是我的身体，而zzw是代表我这个身体的大名 　。
　　但是我还可以起一个小名，如下：
　int& pig = zzw;　
　　也就是说无论是大名zzw还是小名pig都指得是我自己， 叫我什么我都答应。
　　实例如下：
#include using namespace std;int main (){    int zzw = 8;    int& pig = zzw;    cout << zzw << endl << pig << endl;    cout << "对引用进行修改" <
　　最终的结果如下所示：
88对引用进行修改2020
　　可以看到叫我小名我也答应你了（修改一个变量的引用，实际上就是修改它自己）。
19. C++数据结构
　　在C和C++的数组中可以定义存储相同数据类型的变量。 但是在C++中还提供了数据结构，在这个数据结构里我们可以定义不同类型的变量。
　　具体应用举例如下：
#include #include  using namespace std; // 声明一个结构体类型 Books struct Books{   char  title[50];   char  author[50];   char  subject[100];   int   book_id;}; int main( ){   Books Book1;        // 定义结构体类型 Books 的变量 Book1   Books Book2;        // 定义结构体类型 Books 的变量 Book2    // Book1 详述   strcpy( Book1.title, "C++ 教程");   strcpy( Book1.author, "Runoob");    strcpy( Book1.subject, "编程语言");   Book1.book_id = 12345;    // Book2 详述   strcpy( Book2.title, "CSS 教程");   strcpy( Book2.author, "Runoob");   strcpy( Book2.subject, "前端技术");   Book2.book_id = 12346;    // 输出 Book1 信息   cout << "第一本书标题 : " << Book1.title <
　　另外，数据结构也可以作为参数传递进去，如下所示：
#include #include  using namespace std;void printBook( struct Books book ); // 声明一个结构体类型 Books struct Books{   char  title[50];   char  author[50];   char  subject[100];   int   book_id;}; int main( ){   Books Book1;        // 定义结构体类型 Books 的变量 Book1   Books Book2;        // 定义结构体类型 Books 的变量 Book2     // Book1 详述   strcpy( Book1.title, "C++ 教程");   strcpy( Book1.author, "Runoob");    strcpy( Book1.subject, "编程语言");   Book1.book_id = 12345;    // Book2 详述   strcpy( Book2.title, "CSS 教程");   strcpy( Book2.author, "Runoob");   strcpy( Book2.subject, "前端技术");   Book2.book_id = 12346;    // 输出 Book1 信息   printBook( Book1 );    // 输出 Book2 信息   printBook( Book2 );    return 0;}void printBook( struct Books book ){   cout << "书标题 : " << book.title <
20. C++中的函数重载
　　　文章C++的函数重载无疑是非常棒的，这里仅仅摘录一部分做一个简单的了解，日后必定深入。
　　　
1. 什么是函数重载？
　　函数重载是指在同一作用域内，可以有一组具有相同函数名，不同参数列表的函数，这组函数被称为重载函数。重载函数通常用来命名一组功能相似的函数，这样做减少了函数名的数量，避免了名字空间的污染，对于程序的可读性有很大的好处。
　　下面就是函数重在的例子，即实现一个打印函数：
#includeusing namespace std;void print(int i){        cout<<"print a integer :"<
　　最终的输出如下：
print a integer :12print a string :hello world!
　　即我们调用函数名相同的函数（实现的功能也大抵相似）返回的值确实不同的。
　　
2.为 什么要函数重载？
试想如果没有函数重载机制，如在C中，你必须要这样去做：为这个print函数取不同的名字，如print_int、print_string。这里还只是两个的情况，如果是很多个的话，就需要为实现同一个功能的函数取很多个名字，如加入打印long型、char*、各种类型的数组等等。这样做很不友好！
类的构造函数跟类名相同，也就是说：构造函数都同名。如果没有函数重载机制，要想实例化不同的对象，那是相当的麻烦！
操作符重载，本质上就是函数重载，它大大丰富了已有操作符的含义，方便使用，如+可用于连接字符串等。
补充：
http://www.cnblogs.com/lzjsky/archive/2011/01/24/1943199.html
静态数据成员介绍
结束，有时间了再继续...
2017年3月31日更新（C++进阶）
　　今天刚刚使用MinGW 和 nodepad++ 来编译和执行文件了，和visual C++ 6.0是一样的可以cin也可以cout，还是非常激动的，趁此就多复习一些知识吧。
1. 下面这是一个含有类和对象的最简单的例子：
#include using namespace std;class Person    // L类的定义{public:    void SetInfo()    {        cout<<"Input info to name,sex,age"<>name>>sex>>age;    }    void Show()    {        cout<<"name:"<
　其中class Person用来定义一个名为Person的类，可以把类看做一个模子，然后我们用这个模子就可以创造形形×××的对象来了。值得注意的是，在class定义了之后，需要使用分号作为结束。
　另外，使用public是说其中的内容是公有的，可以被调用的，而privite是私有的，只能在内部被调用。这就体现了著名的封装性的特点。
　这就是面向对象，它引入了类和对象的概念，类是用户自定义的数据类型，对象是该数据类型的变量。
2. 注意使用#define 定义常变量时，只是将变量进行了简单的替换，如下所示：
int x=1; int y=2; #define R x+y #define PI 3.1415926 cout<
而如果我们使用const float PI = 3.14；也是类似的作用，也可以写成 float const PI = 3.14; 两者是等效的。
3、空指针和野指针
　　int *p = 0; 或者是 int *p = NULL; 那么这里的p就是空指针。
　　而int *q; 仅仅声明了这个指针q，但是不知道它指向了哪里，所以说是野的，即野指针。
　　两者是不同的，引入空指针的目的是为了防止使用指针出错，如果出现了空指针就会报错，情况：动态分配内存malloc()函数或new运算符的成功使用不会返回空指针，但是失败了就会返回空指针。
　　如果定义了一个野指针，我们就不知道它到底会指向何处，为了避免不知指针指向了何处，在C++中一般习惯是定义了指针变量后立即初始化为空指针，然后在使用指针之前再给指针变量赋值，使指针有了具体指向之后再使用指针。
4. 指针与const
const int *p;(int const *p; 和前者是一样的） 这个的意思p是常量，即我们不能通过 *p 来修改p所指向的值，但是可以直接修改p所指向的值， 也可以修改p的指向。
#include using namespace std;int main() {    const int *p = NULL;    int a = 20;    int b = 30;    p = &a;    p = &b;    *p = 50; // error: assignment of read-only location "*p"    cout<<*p;}
我们可以修改b的值，这样*p会改变，也可以修改p的指向，但是如果通过*p来修改指向的值就报错，提示*p是只读的。
int *const p; 这里是指p指针是const的，一旦定义了，就不能修改p的指向。
#include using namespace std;int main() {    int *const p = NULL;    int a = 20;    int b = 30;    p = &a; // 报错    cout<<*p;}
这里我已经定义p为空指针了，那么后面p又指向a就会报错。
const int *const p; 这里就是上述的综合，即不能修改p的指向也不能通过*p来修改p所指向的值。
5. void和void指针
　　先说void ， 函数 int func(void){return 0;} 和int func(){return 0;}在C++中都表示不接受任何参数，如果使用func(2)就会报错。但是在c语言中，如果我们使用func(2)就不会报错，所以，为了更加严谨，最好使用void表示不接受参数。 另外我们不能使用void a;这种形式来声明变量，因为void表示无类型的，如果你声明了这个变量，那么分配多少内存呢？ 对吧。
　　但是void是可以声明一个指针的。 答案是可以的。使用void声明一个指针，我们就称为"无类型指针"，或者就称为void指针。 我们知道，一个类型的指针必须指向相同类型的变量，但是void指针就厉害了，它可以指向任意类型的变量。但是void类型的指针在读取值和指针的赋值过程中需要进行强制类型转换，原因如下：
　不难想象，无论是什么类型的指针，它指向一个变量的首地址总是一样的，所以我们才可以使用void指针，但问题是： 如果我们希望通过这个指针来访问他所指向的变量，就得知道这个变量的类型啊，因为不同类型的变量的内存大小是不一样的，所以得强制类型转化，告诉它这个变量的大小是多少，才可以读取。
#include using namespace std;int main() {    void *p;    int a = 5;    double b = 10;    p = &a;    cout<< *(int *)p;}
　　如上，必须进行强制类型转换才能正确的输出p所指向的变量，注意：强制类型转换是(int *)因为这是一个指针。
6. 使用new和delete动态管理内存单元
　　和声明一个变量不同，使用new一般是用来申请指针的内存单元的，并且前者是在编译过程中分配的内存，而后者是在程序的执行过程中才分配的内存，所以是动态分配内存。 另外，new之后一定要delete，因为声明的方式可以自动地清除内存，但是new的方式只能使用delete来清除内存。
#include using namespace std;int main() {    int *p = NULL;    p = new int;    delete p;         cout<<*p;}
最终输出的是16323288， 注意这是new到的一个内存，所以这是一个随机数。 且new和delete必须要成对存在。我们还可以在new的时候初始化，即p = new int(20); 那么*p就是20了。
那我们怎么申请连续空间的内存呢？ 方法也很简单，就是p = new int[20]; 这样就可以申请到长度为20的连续空间了。
7. 引用，如 int &a = b;这就是a对b的引用，可以看做a是b的另外一个名字，但是他们指向的同一个内存单元，所以对他们任意一个的修改都是有效的。 下面我们看三个典型的例子，分别是值传递、指针传递和引用传递。
#include using namespace std;int fun(int a, int b){    int temp;    temp = a;    a = b;    b = temp;}int main() {    int x = 5, y = 10;    cout<<" x:"<
　　最后的结果都是x为5，y为10。这就是典型的值传递，即穿进去之后，内部的改变不会影响外面的。
　　
#include using namespace std;int fun(int *a, int *b){    int temp;    temp = *a;    *a = *b;    *b = temp;}int main() {    int x = 5, y = 10;    cout<<" x:"<
　　最后的结果是： x:5,y:10 后面是x:10,y:5 可以发现这个交换就完成了。 这就是典型的指针传递或地址传递。这样，在内部修改的*a和*b实际上就在修改x和y。
#include using namespace std;int fun(int &a, int &b){    int temp;    temp = a;    a = b;    b = temp;}int main() {    int x = 5, y = 10;    cout<<" x:"<
　　最后的结果是： x:5,y:10 后面是x:10,y:5 可以发现这个交换就完成了。 这就是典型的引用传递，两者都是指向同样的内存，所以可以完成修改。
值得注意的是，在引用中，还是有const的，如const int &a = b;表示a这个引用是不能被修改的，即不能通过a来修改他和b共有的内存，即a的权利只是读。如下：
#include using namespace std;int main() {    int x=10;    const int &b = a;    b = 20;    cout<
编译过程中就会提示b是只读的。
8. 函数的相关问题
　　在c++中，无论你写了多少，总是从main函数中开始执行，并且在调用一个函数之前，我们必须进行函数声明（函数声明和函数定义不同，所以说需要用分号作为结尾），另外，main函数是最重要的，我们强烈建议将函数定义写在main函数之后，另外， 在函数声明的时候我们只需要将函数的类型声明即可， 名称不重要，编译时不会检查。
　　除此之外，我们还可以提供默认的参数，即如果没有传递该参数，我们就使用默认的。且默认的参数可以使其中的一个或几个（当然可以使全部），但是如果不是全部时， 默认的参数需从最右边开始。
#include using namespace std;int main() {    int add(int,int,int =50);    //int add(int,int,int c=50); // 这个也是有效的，在函数什么声明的过程中，不需要制定名字。    cout<
　　值得注意的是，如果使用默认参数，那么定义和声明都需要指明默认的值，否则就会报错。 虽然我们可以直接写在int main()的上面，这样就不需要声明了，但是这并不是我们所推荐的。
　　函数重载： 即函数参数的类型不同或个数不同或函数参数的类型和个数都不相同。函数的返回值可以相同也可以不同，但是绝不能函数的参数形同而只有返回值不同，这不是函数的重载。如下：
#include using namespace std;int main() {    int add(int,int);    int add(int,int,int);    int a = 5,b = 8;    int x = 14,y = 15, z =45;    cout<
　　一个输出的是13，另一个输出的是74。
9. 详解名字空间
　 我之前所写的所有代码中都包括： using namespace std; 不难理解，这一定和命名空间是由关系的。下面我将从头说起。。。
　（1）为什么要使用名字空间？
　　 简单的说，使用名字空间是为了解决程序中名字冲突的问题，即在程序运行过程中遇到相同名字的变量，系统不能正确的区分它们。
　　在一个小型系统里，只要我们注意一下变量就不会重复，但是对于一个大型的系统，由多人合作完成，我们通过#include的方式来引入不同的开发人员所编写的程序，那就难免会遇到重名的情况，这样就导致类全局名字空间污染。
　　正是为了避免这样的问题，后来引入了名字空间的机制。（在早期的C++中，也是没有名字空间的概念的）。
　（2）什么是名字空间？
　　所谓名字空间就是一个由程序设计者命名的内存区域。他可以根据需要建立一些有名字的命名空间域，把一些全局标识符分别放在不同的名字空间中，这样就可以解决变量冲突的问题了。 就向一个文件下有一个目录，每个子目录又有一堆文件，那么各个目录下的文件是可以重名的，于是就解决了问题。
　（3）如何使用名字空间？
　　语法如下：　
namespace 名字空间名{    定义成员  }
其中成员的类型包括：常量、变量、函数、结构体、类、模板等，还可以是名字空间，即名字空间的嵌套。如下：
namespace ns{   const int RATE = 0.08;   double money;   double tax()  {    return money * RATE;  }    namespace ns2  {      int count;  }}
如果要访问名字空间ns中的成员，就可以采用"名字空间::成员名"的方法，如ns::RATE、ns::money、ns::tax()、ns2::count等等。
我们还可以给ns起一个别名，即namespace anotherns = ns; 那么就是anotherns::money就和 ns::money的效果是一样的了。
　　技巧： 使用using 名字空间的成员名，如using ns::tax 后面再访问tax()的时候就相当于ns::tax()，这样可以避免在每一次访问名字空间的成员时用名字空间限定，来简化名字空间的使用。
　　技巧： 使用using 名字空间名， 如果在一段程序中经常访问一个名字空间中的多个成员，就要多次使用using名字空间成员名，这是很不方便的，所以C++提供了using namespace 语句，一次就能声明一个名字空间中的全部成员，格式为：
　　using namespace 名字空间名；
　　注意1： 该声明下使用变量只在该声明的作用域内有效。
　　注意2： 如果同时使用using namespace引入了多个命名空间，那么要保证它们没有相同的变量名，否则还是会有命名冲突。
　　
　　（4）标准名字空间 std
　　即standard，标准的名字空间，系统预定义的头文件中的函数、类、对象和类模板都是在std中定义的。
　　所以，第二行都有一个using namespace std; 这就在全局中起作用了，如果不用的话，我们就要使用std::来访问了，如下所示：
#include int main() {        std::cout << "Hello world";}
　　如果引入了大量的系统的函数、类等，我们就需要添加没玩没了的ｓｔｄ：：，然后这是很不方便的。
　　
9. 字符串变量
　　我们知道在c中使用char来定义字符串和字符串数组都是十分麻烦的。而在c++中，由于有了类的概念，并且系统自带的就有string类，我们只要在开头引入即可，即#include 然后我们就可以使用string类了。
　　如 string str = "hello"; 这样就定义了一个字符串变量，我们可以对这个变量进行大量的操作，如strcat、strcopy等等。另外，还可以赋值，并且不需要考虑内存的问题。
　　和c中的最大的不同是，在c中的字符串，最后自动添加'\0'作为结尾，而string实例化的对象不需要使用'\0'作为结尾。且可以使用str[0]等来访问到每一个字符。
　　在c++中，还支持数组，如 string str = {"hello", "world", "hhahha"}; 即我们不需要考虑每一个元素的长度是否一致等。 就是这个方便。