1 不使用sizeof，求类型长度

用指针移动计算来测量字节大小。

#include<iostream>using namespace std;//#define lengthofType(val) (char*)(&val+1)-(char*)&val#if(1)template <class any>int lengthofType(any* p){ return int(p+1)-int(p);}#endifvoid main(){ int* i; double* q; char a[11]; cout<<lengthofType(i)<<endl; cout<<lengthofType(q)<<endl; cout<<lengthofType(&a)<<endl; //cout<<lengthofType(a)<<endl; system("pause");}/*4811*/

2 数组的地址与首元素地址

#include<iostream>using namespace std;void main(){	int next = 16;	int a[5] = {1,2,3,4,5};	int *p1 = (int*)(&a+1);	int *p2 = a+5;	int *p3 = a;	cout<<*p1<<" "<<*p2<<" "<<next<<endl;	cout<<sizeof(a)<<" "<<sizeof(p3)<<endl;	cout<<"数组元素数量："<<sizeof(a)/sizeof(a[0]); system("pause");}/*16 16 1620 4数组元素数量：5*/

一般而言，对指针进行加1操作，得到的将是下一个元素的地址。因此，只要确定了指针指向的类型，就可以很容易地求出指针+1的结果。

也就是说，一个类型为T的指针移动，是以sizeof(T)字节为单位来移动的。

对于数组int a[5]，a表示数组首元素的地址，而&a表示整个数组的首地址。

数组a有两层意思：

I a表示数组首元素的地址（类型为int*）；

II a表示大小为5个int元素的数组。

数组名本身在计算中会自动转化为第一个元素的地址，但sizeof测试的时候不做转换，此时表示的是整个数组。这就是所谓的上下文。

在计算int *p2 = a+5;时，a表示的是数组首元素地址;

计算sizeof(a)时，a表示的是整个数组。

计算&a+1时，a是一个数组指针(int*)[]，加1的操作是移动sizeof(a)字节数量的空间，这里是从首地址起移到了5个int数量的字节，

到了其后相邻的一个元素，相邻元素就是int next所在内存空间。

3 不使用循环语句，输出1－100连加的值

利用类类型的构造函数和静态数据成员：

#include<iostream>using namespace std;class temp{	static int n;	static int sum;public:	temp();	static void reset();	static int getsum();};int temp::n=0;//类定义外初始化静态变量int temp::sum=0;temp::temp(){	++n; 	sum+=n;}void temp::reset(){	n=0; 	sum=0;}int temp::getsum(){return sum;}int sum(int n){	temp::reset();	temp *a = new temp[n];	delete []a;	a=0;	return temp::getsum();}void main(){ cout<<sum(100)<<endl; system("pause");}

4 不使用判断语句如何判断两个int变量中的最大值和最小值

4.1 利用绝对值的方法

	int a =3, b=4;			int max=((a+b)+abs(a-b))/2;			cout<<max<<endl;	int min=((a+b)-abs(a-b))/2;	cout<<min<<endl;

4.2 对变量的差值进行移位操作，通过判断差值的符号就可以确定两个值的大小。

	int a =3, b=4;	int c=a-b;	int max=(unsigned)c>>(sizeof(int)*8-1);//判断差值的符号	if(!max)		cout<<a<<endl;	else		cout<<b<<endl;

4.3 移位操作

void comp(int a,int b){	static char* op[]={"=","<",">"};	int i;	i = (unsigned(a-b)>>31)+(unsigned(b-a)>>31)*2;	cout<<a<<op[i]<<b<<endl;}void main(){	int a =3, b=4;	comp(3,4); system("pause");}

5 不使用库函数、也不使用临时变量求字符串长度

使用递归的方法：

int Strlen(const char*s){	if(*s!='\0')		return 1+Strlen(++s);	else return 0;}

对照一下使用临时变量的方法：

int Strlen(const char*str){	int len = 0;	if(str==NULL)		return 0;	for(;*str++!='\0';)		len++;	return len;}

6不使用迭代，使用递归实现一维数组求和

#include<iostream>using namespace std;int GetSum(int* arr, int n){	return n ==0?0:GetSum(arr,n-1)+arr[n-1];}void main(){	int arr[]={1,2,3,4,5}; cout<<GetSum(arr,sizeof(arr)/sizeof(arr[0]))<<endl; system("pause");}

7 使用单循环实现二维数组和三维数组求和

内存的数据存储都是线性顺序存储，所谓的二维数组可以理解为数组的数组，三维数组可以理解为其元素是一个二维数组。不管多少维数组，在内存中都是线性顺序存储的。其下标的乘积就是其在线性序列中的相对（偏移）位置。线性序列都可以通过一个单循环来完成。当然，如果通过维度和嵌套循环实现的嵌套循环控制结构更直观和贴近现实。

#include<iostream>using namespace std;int Arr2Sum(int arr[][4], int i, int j){	int sum = 0;	for(int n=0; n<i*j;n++)	{		sum+=arr[n/j][n%j];		//cout<<n<<" "<<n/j<<" "<<n%j<<" "<<arr[n/j][n%j]<<endl;	}	return sum;}int Arr3Sum(int arr[][3][2], int i, int j,int k){	int sum = 0;	for(int n=0; n<i*j*k;n++)	{		sum+=arr[n/(j*k)][(n/k)%j][n%k];			}	return sum;}void main(){ int arr[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};int arr3[2][3][2]={1,2,3,4,5,6,7,8,9,10,11,12};	cout<<Arr2Sum(arr,3,4)<<endl;	cout<<Arr3Sum(arr3,2,3,2)<<endl; system("pause");}/*output:7878*/

对于以下数组，在声明的时候同时进行了初始化：

 int arr[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};int arr3[2][3][2]={1,2,3,4,5,6,7,8,9,10,11,12};

也可以写成：

 int arr[][4]={1,2,3,4,5,6,7,8,9,10,11,12};int arr3[][3][2]={1,2,3,4,5,6,7,8,9,10,11,12};

其左边的第一维的维度可以略写，是因为其维度可以通过右边的初始化表达式自行推断出来。

也就是说，其维度必须是常量或常量表达式，或第一维可以推导出来。

当数组用作函数参数时，一维数组int arr[]或以写成指针形式int* arr（其实质都是用指针做参数），相当于[]换成了*，然后换了一个位置。但对于多维数组，写法略有不同，只有左边的第一维可以写成指针的形式，并要用括号提升优先级，让其表示一个数组指针（而不是一个指针数组），指向一个数组：

int Arr2Sum(int (*arr)[4], int i, int j){;}

表示的是一个数组指针，每个指针指向一个一维4个元素的数组。

int Arr3Sum(int (*arr)[3][2], int i, int j,int k){;}

表示的是一个数组指针，每个指针指向一个二维的三行两列的3*2个元素的数组。

上述的语法定义，说白一点，就是n维数组是n-1维数组的嵌套，n-1维是n-2维的嵌套，或者说，n-2维数组是n-1维数组的元素……

如以下实例，函数sum(int *a, int size)求一个一维数组元素的和，在一个二维数组中，就可以循环调用sum()来求二维数组中嵌套的一维数组的和：

8 二分查找的递归与非递归实现

二分查找的递归写法用迭代的方法比较容易理解：

#include<iostream>using namespace std;int binarySearchLoop(int arr[], int len, int findData){	if(arr==NULL || len <=0)		return -1;	int start = 0;	int end = len-1;	while(start<=end)	{		int mid = start+(end-start)/2;		if(arr[mid] == findData)			return mid;		else if(findData < arr[mid])			end = mid-1;		else			start = mid+1;	}	return -1;}int binarySearchRecursion(int arr[], int findData, int start, int end){	if(arr==NULL || start>end)		return -1;		int mid = start+(end-start)/2;		if(arr[mid] == findData)			return mid;		else if(findData < arr[mid])			binarySearchRecursion(arr, findData, start, mid-1);		else			binarySearchRecursion(arr, findData, mid+1, end);}void main(){	int arr[] = {1,2,3,4,5,6,7,8};	int len = sizeof(arr)/sizeof(arr[0]);	int index = binarySearchLoop(arr,len,4);	int index2 = binarySearchRecursion(arr,4,0,len-1); cout<<index<<endl;	cout<<index2<<endl; system("pause");}

－End－