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;
}

运行结果：

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