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];
    // 初始化ruler
    ruler[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;
}

运行结果：

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