c++知识整理编程模块

最近开始看c++primer，做一点记录！

函数的基础知识:

要使用函数，必须完成：

1. 提供函数的定义

2.提供函数原型

3.调用函数

了解一下，函数是如何返回它的返回值：

函数会通过将返回值复制到指定的cpu寄存器或者内存单元中来将其返回，随后，调用程序将查看该内存单元，在这一过程中，返回函数和调用函数必须就该内存中存储的数据的类型达成一致，函数原型将返回值类型告知调用程序，而函数的定义决定被调函数应该返回什么类型的数据。在原型中提供与定义中相同的信息似乎有些多余，但是这样做确实有道理。例如要让信差从办公室的桌上取走一些物品，则向信差和办公室的同事都交代自己的意图，将提高信差完成这项工作的概率(C++ primer)

函数原型与函数定义：

函数原型：即函数声明

函数定义：函数的定义

1. c++中为什么需要提供函数原型

原型描述了函数到编译器的接口，也就是说，它将函数的返回值类型和参数的类型，数量告诉编译器。

例如函数原型：

double cube(double x);

首先，原型会告诉编译器cube()函数有一个double类型的参数，如果程序没有提供这样的参数，原型将让编译器能够捕获到这种错误。在cube()函数完成计算之后，将把返回值放到指定的位置(CPU寄存器或者内存中),然后调用函数（main()函数）将从这个指定的位置取得返回值，由于原型中指出了函数cube的返回值类型为double,因此编译器知道应该检索多少个字节以及如何解释它们。

这样做可以解决编译时的效率问题，如果没有函数原型，编译器在编译过程中在文件中查找函数的定义的话，会比较耗时，同时在查找的过程中会停止对main()函数的编译，而且函数很可能不在文件中，这样，编译器将无权访问函数代码。

所以，综上所述，原型可以确保以下几点：

1. 编译器正确处理函数的返回值

2. 编译器检查使用的参数数目是否正确

3. 编译器检查使用的参数类型是否正确

上述在编译阶段进行的原型化称为静态类型检查（static type checking）

函数和数组

数组做为函数的指针，将数组的首地址作为参数传递给函数，，节省可复制整个数组所需的内存空间和时间。尤其是在遇到大的数组的时候。

int sum(int array[], int size)
{int M = sizeof array;     // sizeof array返回的是指向数组元素的指针 的字节数(大小) // 指针本身并没有指出数组的长度
}
int main(int argc, char *argv[])
{const int arraySize = 8;int cookies[arraySize] = {1,2,3,4,5,6,7,8};int L = sizeof cookies;     // 这里返回的是整个数组的长度(字节数) int total = sum(cookies, arraySize);    return 0;
}

由于上面的原因，所以数组作为函数参数的时候必须显式的传递数组的大小

// 可以选择数组的起始和结束的位置
int total = sum(cookies+3, 4);   // 起始位置， 数组的长度

在数组作为函数的参数时，使用const保护数组：

函数使用普通参数时，这种保护机制将自动实现，因为参数按值传递，使用的是实参的副本，但是当参数为数组时，应该考虑如何避免参数被修改。

// 使用const保护数组参数
void show_array(const double arr[], int n);

使用const限制数组参数，这意味着原始数组不一定得是常量，而是意味着不能再show_array()函数中修改数组中元素的值。

将数组的区间作为参数传入函数，在STL中，使用 “超尾” 的概念来指定区间，如数组名是指向数组第一个元素的指针，数组大小i为n,则数组名+n是执行数组中最后一个元素的后一个位置，所以会有“超尾”这个概念。

例如对之前的sum()函数做修改：

#include <iostream>
#include <algorithm>
using namespace std;int sum(const int* begin, const int* end)
{int total = 0;const int* pt;   // pt指向常量的指针 for(pt=begin; pt<end; pt++){total += *pt;} return total;
}int main(int argc, char *argv[])
{const int arraySize = 8;int cookies[arraySize] = {1,2,3,4,5,6,7,8};cout << sum(cookies, cookies+arraySize) << endl;;return 0;
}

关于const对指针的限制：
1. 可以用const来修饰指针，让指针指向一个常量对象，防止使用指针来修改指向元素的值

但是要注意：const *pt这样的声明，并不意味着pt指向的值实际就是一个常量，而实意味着对pt而言，这个值是一个常量，不能y用pt来修改他：

int age = 20;    // age不是一个常量
const int* pt = &age;   // pt指向的age值是一个常量。不能修改：
age += 10;    // 可以修改age的值
*pt += 10;    // 不能修改age的值

2.第二种使用const的方式使得无法修改指针的值：

int age = 20;    // age不是一个常量
int* const pt = &age;   // 指针不能被修改，只能指向age
int sage = 80;
pt = &sage;     // 禁止这样修做！

3. 第三种，可以声明指向const对象的const指针：

int age = 20;    // age不是一个常量
const int* const pt = &age;   // 指针不能被修改，只能指向age,且不能通过指针修改age的值

函数，二维数组

// 理解二维数组作为函数参数的原理

int data[3][4] = {{1,2,3,4},{2,3,4,5},{5,6,7,8}};
int sum(int arr[][4], int size)
{// 二维矩阵作为函数的参数// 参数arr相当于一个指针 ，指向数组的第一个元素，//这个数组的每一个元素都有四个元素组成，所以需要传入二维数组的列数//因此 arr[i]是一个由四个元素组成的数组的数组名int total = 0;for(int i=0; i<size; i++){for(j=0; j<4; j++){total += arr[i][j];}} return total;
}

函数与c-风格字符串

包含字符，但是不以空值字符结尾的char类型的数组只是数组，而不是字符串。意味着不必将字符串的长度传递给函数。

#include <iostream>
#include <algorithm>
using namespace std;unsigned int c_in_str(const char* str, char target)  // 寻找字符串中特定字符的个数
{unsigned int count = 0;while(*str)    // != '\0'{ if(*str == target){count++;}str++;}return count;
}int main(int argc, char *argv[])
{char ghost[15] = "helloworld";char* str = "helloworld";cout << c_in_str(ghost, 'o') << endl;cout << c_in_str(str, 'l') << endl;return 0;
}

返回c-风格的字符串

#include <iostream>
#include <algorithm>
using namespace std;char* build_str(char ch, int n)
{char* pstr = new char[n+1];     // new动态分配内存 pstr[n] = '\0';   // 字符串结尾while(n> 0){n--;pstr[n] = ch;} return pstr;
}
int main(int argc, char *argv[])
{char* p = build_str('M', 8);cout << p << endl;delete []p;     // 释放内存    return 0;
}

函数和结构体：

可以将一个结构赋值给另一个结构，也可以按值传递结构，就像普通变量一样。结构作为函数的参数，可以按值传递，但是按值传递的操作实际上函数中使用的是结构的副本（会将结构进行复制）, 所以如果结构包含的数据量比较大的话，则复制结构需要增加内存需求，降低系统的运行速度。所以一般采用 pass by address 或者 pass by reference

#include <iostream>
#include <algorithm>
using namespace std;// 定义结构
struct travel_time
{int hour;int minute;travel_time(int hour, int minute){this->hour = hour;this->minute = minute;}travel_time(){this->hour = 0;this->minute = 0;}};const int minutes_perH = 60;
travel_time sum(travel_time, travel_time);    // 计算时间之和
void show_time(travel_time);     // 显示时间 int main(int argc, char *argv[])
{// travel_time time1 = {12, 45}; // 如果没有定义构造函数，则用这种方法初始化结构体 travel_time time1(12, 45);   travel_time time2(1, 35);        // 定义了构造函数的初始化方法 show_time(sum(time1, time2)); return 0;
}travel_time sum(travel_time t1, travel_time t2)
{travel_time total;total.minute = (t1.minute + t2.minute) % minutes_perH;total.hour = t1.hour + t2.hour + (t1.minute + t2.minute) / minutes_perH;return total;
}void show_time(travel_time t)
{cout << "The total time is: " << t.hour << ":" << t.minute << endl;
}

坐标的转化：

#include <iostream>
#include <algorithm>
#include <cmath>using namespace std;struct rect
{double x;double y;rect(double x, double y){this->x = x;this->y = y;}rect(){this->x = 0;this->y = 0;}
};     // 定义结构struct polar
{double dist;double angle;polar(double dist, double angle){this->dist = dist;this->angle = angle;}polar(){this->dist = 0;this->angle = 0;}
}; // prototype
polar rect2polar(rect r)
{polar p;p.dist = sqrt(r.x*r.x + r.y*r.y);p.angle = atan2(r.y, r.x);return p;
}void show_polar(polar p)
{const double rad2degree = 180.0/3.1415;cout << "The distance is " << p.dist << endl;cout << "The degree is " << p.angle*rad2degree << endl;
}int main(int argc, char *argv[])
{rect r;polar p;cout << "Enter the rect.x and rect.y: ";while(cin >> r.x >> r.y){p = rect2polar(r);show_polar(p);cout << "Next two numbers:(q to quit)";}return 0;
}

运行结果：

while(cin >> x >> y)， cin是一个istream对象， cin >> x也是一个istream对象，因此cin >> x >> y最终返回的也是一个istream对象(cin), 而cin在被用于测试表达式中时，将根据输入是否成功，被转换为bool型的true和false.所以如果输入q, cin将知道输入不正确，从而q将被留在队列中，并返回一个被转换为false的值。

递归与分治：

例：绘制标尺

#include <iostream>
#include <algorithm>
#include <cmath>using namespace std;// 绘制标尺
void subdivide(char ar[], int low, int high, int level)
{// 递归函数， 采用分治的方法 if(level == 0){return;}int mid = (low + high) / 2;ar[mid] = '|';subdivide(ar, low, mid, level-1);subdivide(ar, mid, high, level-1);
} int main(int argc, char *argv[])
{const int LEN = 66;const int divs = 6;char ruler[LEN];// 初始化rulerruler[LEN-1] = '\0';for(int i=1; i<LEN-2; i++){ruler[i] = ' ';} int min_index = 0;int max_index = LEN-2;ruler[min_index] = ruler[max_index] = '|';cout << ruler << endl;for(int i=1; i<=divs; i++){subdivide(ruler, min_index, max_index, i);cout << ruler << endl;// 将数组设置为空，以便进行下一次的分割for(int j=1; j<LEN-2; j++){ruler[j] = ' ';} }return 0;
}

运行结果：

------------------------------------------------------------------分割线------------------------------------------------------------------