2019-01-10 09:32:08 zhhp1001 阅读数 194
  • 数据结构与算法C/C++实现)视频教程

    C/C++实现数据结构与算法视频培训课程全面介绍计算机行业,基本的数据结构与算法,既有理论的深度也有实战的技法。课程全程讲师手敲代码,一步步代你走进数据结构与算法。 本课程涉及的数据结构与算法有,栈,队列,单向链表,双向循环链表,树,二叉树,搜索二叉树,平衡搜索二叉树,冒泡,选择,直插,希尔,,归并等,课程还涉及深度优先算法与广度优先算法等等。

    3582 人正在学习 去看看 王桂林

要补基础了,大概浏览了以下四本书:

数据结构与算法分析 C++语言描述  4th  这本书内容不错...但是这个翻译水平是我见过最烂的...看原版吧这本。

算法导论  数学推导比较多,伪代码实现, 感觉应该在阅读其他书籍入门后再来看

大话数据结构   C语言描述,代码质量不行...  厕所读物 可看可不看

邓俊辉  数据结构 (C++语言版) 比较了上面几本书之后,发现这本是真不错,配合习题集  ,内容丰富,代码规范。

2018-08-08 14:52:46 qq_20304723 阅读数 73
  • 数据结构与算法C/C++实现)视频教程

    C/C++实现数据结构与算法视频培训课程全面介绍计算机行业,基本的数据结构与算法,既有理论的深度也有实战的技法。课程全程讲师手敲代码,一步步代你走进数据结构与算法。 本课程涉及的数据结构与算法有,栈,队列,单向链表,双向循环链表,树,二叉树,搜索二叉树,平衡搜索二叉树,冒泡,选择,直插,希尔,,归并等,课程还涉及深度优先算法与广度优先算法等等。

    3582 人正在学习 去看看 王桂林

2018.8.8     《剑指Offer》从零单刷个人笔记整理(66题全)目录传送门​​​​​​​

这道题原版是不要求调整后的元素相对顺序与原序列一致的,那其实就可以用首尾对称调换的方法做。后面C++的代码是按原题做的标准答案。现在要求调整后的元素相对顺序与原序列一致,也不难。

思路一:奇偶两个flag point从头出发,oddpoint停在第一个偶数上,evenpoint继续前进到该偶数后的第一个奇数(这么说好像应该两个point名称对调一下,不要在意啦),接着让这两个flag point之间的子序列做一个冒泡,使得奇数冒到最前(如原子序列为6827,冒泡完后为7682)。接着oddpoint前进1格,evenpoint继续前行直到循环结束即可。

思路二:创建一个新数组,遇到偶数就保存到新数组,同时删除原数组中的偶数。最后将新数组中的所有偶数添加到老数组奇数序列后即可。


原版题目描述

输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有的奇数位于数组的前半部分,所有的偶数位于数组的后半部分

升级版题目描述

保证奇数和奇数,偶数和偶数之间的相对位置不变。


升级版Java实现(思路一):

/**
 * 
 * @author ChopinXBP 
 * 输入一个整数数组,实现一个函数来调整该数组中数字的顺序
 * 使得所有的奇数位于数组的前半部分,所有的偶数位于数组的后半部分,并保证奇数和奇数,偶数和偶数之间的相对位置不变。
 * 
 *
 */

public class reOrderArray_13 {

	static int[] array = {8, 3, 7, 5, 1};
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Solution(array);
		for(int i = 0;i<array.length;i++){
			System.out.print(array[i]);
		}
	}
	
	public static void Solution(int[] array){
		int oddflag = 0;
		int evenflag = 0;
		
		while(evenflag < array.length){
			//奇偶flag前进到第一个偶数开始进入循环
			if((array[oddflag] & 0x01) == 0){				
				while(evenflag < array.length){
					//将下一个奇数与其之前的所有偶数进行一次冒泡
					if((array[evenflag] & 0x01) == 1){
						Swap(array, oddflag, evenflag);
						oddflag++;
					}
					evenflag++;
				}			
			}
			oddflag++;
			evenflag++;
			
		}
		
	}
	
	public static void Swap(int[]array, int i, int j){
		while(j != i){
			int tmp = array[j - 1];
			array[j - 1] = array[j];
			array[j] = tmp;
			j--;
		}
	}
	

}

升级版C++实现示例(思路二):

//第二个思路:再创建一个数组
class Solution{
public:
    void reOrderArray(vector<int> &array) {
 
        vector<int> array_temp;
        vector<int>::iterator ib1, ie1;
        ib1 = array.begin();
 
 
        for (; ib1 != array.end();){            //遇见偶数,就保存到新数组,同时从原数组中删除
            if (*ib1 % 2 == 0) {
                array_temp.push_back(*ib1);
                ib1 = array.erase(ib1);
            }
            else{
                ib1++;
            }
 
        }
        vector<int>::iterator ib2, ie2;
        ib2 = array_temp.begin();
        ie2 = array_temp.end();
 
        for (; ib2 != ie2; ib2++)             //将新数组的数添加到老数组
        {
            array.push_back(*ib2);
        }
    }
};

原版+测试代码:

#include "stdafx.h"

void Reorder(int *pData, unsigned int length, bool (*func)(int));
bool isEven(int n);

// ====================方法一====================
void ReorderOddEven_1(int *pData, unsigned int length)
{
    if(pData == NULL || length == 0)
        return;

    int *pBegin = pData;
    int *pEnd = pData + length - 1;

    while(pBegin < pEnd)
    {
        // 向后移动pBegin,直到它指向偶数
        while(pBegin < pEnd && (*pBegin & 0x1) != 0)
            pBegin ++;

        // 向前移动pEnd,直到它指向奇数
        while(pBegin < pEnd && (*pEnd & 0x1) == 0)
            pEnd --;

        if(pBegin < pEnd)
        {
            int temp = *pBegin;
            *pBegin = *pEnd;
            *pEnd = temp;
        }
    }
}

// ====================方法二====================
void ReorderOddEven_2(int *pData, unsigned int length)
{
    Reorder(pData, length, isEven);
}

void Reorder(int *pData, unsigned int length, bool (*func)(int))
{
    if(pData == NULL || length == 0)
        return;

    int *pBegin = pData;
    int *pEnd = pData + length - 1;

    while(pBegin < pEnd) 
    {
        // 向后移动pBegin
        while(pBegin < pEnd && !func(*pBegin))
            pBegin ++;

        // 向前移动pEnd
        while(pBegin < pEnd && func(*pEnd))
            pEnd --;

        if(pBegin < pEnd)
        {
            int temp = *pBegin;
            *pBegin = *pEnd;
            *pEnd = temp;
        }
    }
}

bool isEven(int n)
{
    return (n & 1) == 0;
}

// ====================测试代码====================
void PrintArray(int numbers[], int length)
{
    if(length < 0)
        return;

    for(int i = 0; i < length; ++i)
        printf("%d\t", numbers[i]);

    printf("\n");
}

void Test(char* testName, int numbers[], int length)
{
    if(testName != NULL)
        printf("%s begins:\n", testName);

    int* copy = new int[length];
    for(int i = 0; i < length; ++i)
    {
        copy[i] = numbers[i];
    }

    printf("Test for solution 1:\n");
    PrintArray(numbers, length);
    ReorderOddEven_1(numbers, length);
    PrintArray(numbers, length);

    printf("Test for solution 2:\n");
    PrintArray(copy, length);
    ReorderOddEven_2(copy, length);
    PrintArray(copy, length);

    delete[] copy;
}

void Test1()
{
    int numbers[] = {1, 2, 3, 4, 5, 6, 7};
    Test("Test1", numbers, sizeof(numbers)/sizeof(int));
}

void Test2()
{
    int numbers[] = {2, 4, 6, 1, 3, 5, 7};
    Test("Test2", numbers, sizeof(numbers)/sizeof(int));
}

void Test3()
{
    int numbers[] = {1, 3, 5, 7, 2, 4, 6};
    Test("Test3", numbers, sizeof(numbers)/sizeof(int));
}

void Test4()
{
    int numbers[] = {1};
    Test("Test4", numbers, sizeof(numbers)/sizeof(int));
}

void Test5()
{
    int numbers[] = {2};
    Test("Test5", numbers, sizeof(numbers)/sizeof(int));
}

void Test6()
{
    Test("Test6", NULL, 0);
}

int _tmain(int argc, _TCHAR* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();

    return 0;
}

#Coding一小时,Copying一秒钟。留个言点个赞呗,谢谢你#

2012-04-01 02:51:23 zhouzhipen 阅读数 3788
  • 数据结构与算法C/C++实现)视频教程

    C/C++实现数据结构与算法视频培训课程全面介绍计算机行业,基本的数据结构与算法,既有理论的深度也有实战的技法。课程全程讲师手敲代码,一步步代你走进数据结构与算法。 本课程涉及的数据结构与算法有,栈,队列,单向链表,双向循环链表,树,二叉树,搜索二叉树,平衡搜索二叉树,冒泡,选择,直插,希尔,,归并等,课程还涉及深度优先算法与广度优先算法等等。

    3582 人正在学习 去看看 王桂林

CSDN论坛升级的时候经常出现的那个无名游戏(原版游戏),我把它移植成C++版的了。

对原来的游戏算法做了少量的修改,也不知道难度有没有提高,反正还是很简单就给围住了。

为了方便修改算法,本游戏中使用了嵌入式脚本,游戏算法全部使用脚本完成。

关于脚本介绍请点这里




目录下的"game.c"是脚本文件,如果有哪位大仙的AI算法精通,可以试着改改。

核心AI算法:

var function ComputerTryMove()
	{
		int x=this->computerPos.x;
		int y=this->computerPos.y;

 		if(x<=0 || y<=0 || x>=this->mapSize || y>=this->mapSize)//检查是否已经到达边界
  			return -1;



//计算八个方向可移动距离
		int d[8]=0;
		int& px=this->mapData[x];
		while(px[--y]==NULL_ID )
			d[0]++;
		if(px[y]==BORDER_ID)
			d[0]=MAX_LENGTH-d[0];

		int& px=this->mapData;
		y=this->computerPos.y;
		while(px[--x][--y]==NULL_ID)
			d[1]++;
		if(px[x][y]==BORDER_ID)
			d[1]=MAX_LENGTH-d[1];

		x=this->computerPos.x;
		y=this->computerPos.y;
		while(px[--x][y]==NULL_ID)
			d[2]++;
		if(px[x][y]==BORDER_ID)
			d[2]=MAX_LENGTH-d[2];

		x=this->computerPos.x;
		while(px[--x][++y]==NULL_ID)
			d[3]++;
		if(px[x][y]==BORDER_ID)
			d[3]=MAX_LENGTH-d[3];

		x=this->computerPos.x;
		y=this->computerPos.y;
		while(px[x][++y]==NULL_ID)
			d[4]++;
		if(px[x][y]==BORDER_ID)
			d[4]=MAX_LENGTH-d[4];

		y=this->computerPos.y;
		while(px[++x][++y]==NULL_ID)
			d[5]++;
		if(px[x][y]==BORDER_ID)
			d[5]=MAX_LENGTH-d[5];

		x=this->computerPos.x;
		y=this->computerPos.y;
		while(px[++x][y]==NULL_ID)
			d[6]++;
		if(px[x][y]==BORDER_ID)
			d[6]=MAX_LENGTH-d[6];

		x=this->computerPos.x;
		while(px[++x][--y]==NULL_ID)
			d[7]++;
		if(px[x][y]==BORDER_ID)
			d[7]=MAX_LENGTH-d[7];


//找出可移动的最长距离或离边界最短距离
		int max=-1;
		for(int i=0;i<8;i++)
		{
			if(d[i]>d[max])
				max=i;
			else if(d[i]==d[max])
			{
				if(Rand(0,1)==1)
					max=i;
			}
		}
		
		if(d[max]==0)
			return 1;

		int& x=this->computerPos.x;
		int& y=this->computerPos.y;


//向找出的最优方向移动
		px[x][y]=NULL_ID;
		switchto(max)
		{
		case 0:
			y--;
		case 1:
			x--;
			y--;
		case 2:
			x--;
		case 3:
			x--;
			y++;
		case 4:
			y++;
		case 5:
			x++;
			y++;
		case 6:
			x++;
		case 7:
			x++;
			y--;
		}

		if(px[x][y]==BORDER_ID)//是否已经到达边界?
		{
			px[x][y]=CPU_ID;
			return -1;
		}
		px[x][y]=CPU_ID;
		return 0;
	}



你赢了之后会放烟花



源码下载
压缩包中有源码(全部工程源码)和编译好的游戏文件。
注意(一定要意):编译工具是VS2008的,上次一个计算器的源码就有很多人用VC6打不开。

下载地址




2014-06-18 16:50:28 suifeng50 阅读数 3094
  • 数据结构与算法C/C++实现)视频教程

    C/C++实现数据结构与算法视频培训课程全面介绍计算机行业,基本的数据结构与算法,既有理论的深度也有实战的技法。课程全程讲师手敲代码,一步步代你走进数据结构与算法。 本课程涉及的数据结构与算法有,栈,队列,单向链表,双向循环链表,树,二叉树,搜索二叉树,平衡搜索二叉树,冒泡,选择,直插,希尔,,归并等,课程还涉及深度优先算法与广度优先算法等等。

    3582 人正在学习 去看看 王桂林

本文参考了李春葆版本的数据结构上机指导,但是原版是c代码,

本文用了c++实现,并且修复了深度优先搜索非递归的一个bug。

graph.cpp文件:

#include "graph.h"
#include <queue>
#include <stack>
int visited[MAXV ];
MGraph ::MGraph(int A[100][10], int nn , int ee)
{
                e= ee ;
                n= nn ;
                 for (int i=0;i<n;i++)
                {
                                 for (int j=0;j<n;j++)
                                                edges[i][j]= A [i][j];
                }
}

void MGraph ::DispMat( MGraph g )
{
                 int i,j;
                 for (i=0;i<g .n;i++)
                {
                                 for (j=0;j<g .n;j++)
                                                cout<< g .edges[i][j]<<"       " ;
                                cout<<endl;
                }

}


ALGragh ::ALGragh(int a[ MAXV][10], int n , int e)
{
                 ALGragh ::n=n ;
                 ALGragh ::e=e ;
                 for (int i=0;i< n;i++)
                {
                                adjlist[i].firstarc= NULL ;
                }
                 for (int i=0;i< n;i++)
                                 for (int j= n-1;j>=0;j--)
                                {
                                                 if (a [i][j]!=0)
                                                {     //作用域里面,必须动态分配。直接写ArcNode p(adjlist[i].firstarc,j,a[i][j])会被析构
                                                                 ArcNode *p=new ArcNode (adjlist[i].firstarc,j, a [i][j]);
                                                                adjlist[i].firstarc=p;
                                                }
                                }
}

void ALGragh ::DispAdj( ALGragh * G )
{
                 ArcNode *p;
                 for (int i=0;i< G->n;i++)
                {
                                p= G ->adjlist[i].firstarc; //p指向第一条边
                                 if (p!=NULL )
                                                cout <<i<<":  " ;
                                 while (p!=NULL )
                                {
                                                cout<<(p->adjvex)<< "  " ;//输出终点
                                                p=p->nextarc;     //指向下一条边
                                }
                                cout<<endl;
                }
}


void ALGragh ::DFS( int v, int flag) //深度优先搜索 递归
{
                 if (flag )
                {
                                memset(visited,0, sizeof (visited));
                                 flag =0;
                }

                 if (v >=n || v<0)
                {
                                cout<< "error point!" ;
                                 return ;
                }
                visited[ v ]=1;
                cout<< v <<"  " ;
                 ArcNode *p=adjlist[v ].firstarc;
                 while (p!=NULL )
                {
                                 if (!visited[p->adjvex])
                                                DFS(p->adjvex, flag );
                                p=p->nextarc;
                }
}

void ALGragh ::DFS1( int v//深度优先搜索 非递归
{
                memset(visited,0, sizeof (visited));
                 if (v >=n || v<0)
                {
                                cout<< "error point!" ;
                                 return ;
                }
                 stack <ArcNode *> s;
                visited[ v ]=1;
                cout<< v <<"  " ;
                 ArcNode *q;
                s.push(adjlist[ v ].firstarc);
                 while (!s.empty())
                {
                                q=s.top(); //s.pop();
                                 while (q!=NULL )
                                {
                                                 if (!visited[q->adjvex])
                                                {
                                                                visited[q->adjvex]=1;
                                                                cout<<q->adjvex<< "  " ;      
                                                                s.push(adjlist[q->adjvex].firstarc); //定点进栈
                                                                 break ;
                                                }
                                                 else
                                                {
                                                                q=q->nextarc;        //与当前结点相连的边都访问了(即往该结点走不下去了)     该节点出栈
                                                                 if (q==NULL )
                                                                                s.pop();
                                                }
                                }
                }
}


void ALGragh ::BFS( int v//广度优先搜索
{
                memset(visited,0, sizeof (visited));
                 if (v >=n || v<0)
                {
                                cout<< "error point!" ;
                                 return ;
                }
                 queue <int > q;
                 ArcNode *p;
                q.push( v );
                visited[ v ]=1;
                cout<< v <<"  " ;
                 while (!q.empty())
                {
                                 v =q.front(); q.pop();
                                p=adjlist[ v ].firstarc;
                                 while (p!=NULL )
                                {
                                                 if (!visited[p->adjvex])
                                                {
                                                                visited[p->adjvex]=1;
                                                                cout<<p->adjvex<< "  " ;
                                                                q.push(p->adjvex);
                                                }
                                                p=p->nextarc;
                                }              
                }
}

main.cpp文件:

#include "graph.h"
int main()
{
                 ////////-------图的遍历算法----//////////
                 /*int A[100][6]={
                                {0,5,0,7,0,0},
                                {0,0,4,0,0,0},
                                {8,0,0,0,0,9},
                                {0,0,5,0,0,6},
                                {0,0,0,5,0,0},
                                {3,0,0,0,1,0}
                };*/
                 int A[100][10]={
                                0,1,1,1,0,0,0,0,0,0,
                                1,0,0,1,0,1,1,1,1,0,
                                0,1,0,1,1,1,0,0,0,0,
                                0,0,0,0,0,1,0,0,0,0,
                                0,1,1,1,0,1,0,0,0,0,
                                0,1,0,0,0,0,0,0,0,0,
                                0,1,1,1,0,0,0,1,1,0,
                                0,0,1,1,1,1,1,0,1,0,
                                0,0,1,1,0,0,0,0,0,0,
                                0,0,1,0,0,0,0,0,1,0
                };
                MGraph g(A,10,10);                                                              //图的邻接矩阵类型
                ALGragh G(A,10,10);                                                            //图的临界表类型
                g.DispMat(g);
                G.DispAdj(&G);
                G.DFS(0,1); cout<<endl;
                G.DFS1(0); cout<<endl;

graph.h文件:

#include "C++global.h"//图的数据结构
typedef int InfoType;
#define MAXV 100   //最大顶点个数

//------------------------------------//
//-----------用邻接矩阵存储-------------//
class VertexType     //顶点类型
{
private :
                 int no;      //顶点编号
                 InfoType info; //顶点的其他信息;
};
class MGraph     //图的定义
{
public :    
                 void DispMat(MGraph g);
                MGraph(){n=0;e=0;memset(edges,0, sizeof (edges));}
                MGraph( int A[100][10],int n, int e);
private :
                 int edges[MAXV ][ MAXV]; //邻接矩阵
                 int n,e;               //顶点数,弧数
                 VertexType vexs[MAXV ]; //图的邻接矩阵类型。
};


//------------------------------------//
//------------------------------------//
//------------用临界表存储-------------//
class VNode ;
class ArcNode             //弧结点结构类
{
                 friend class   ALGragh;
                 //friend class VNode;
public :
                ArcNode(){}
                ArcNode( ArcNode *next , int adj, int i)
                {              adjvex= adj ;            nextarc= next;        info= i ;    }
                
private :
                 int adjvex;         
                 ArcNode *nextarc;    //指向下一条弧的指针
                 InfoType info;       //弧先关信息,这里存放权值
};

class VNode {               //头结点类
                 //friend class ArcNode;
                 friend class   ALGragh;
private :
                 int data;              //顶点信息
                 ArcNode *firstarc;     //指向第一条弧
};

typedef VNode AdjList[ MAXV ]; //AdjList是临界表类型

class   ALGragh {     //图的临界表类型
public :
                ALGragh();
                ALGragh( int a[MAXV ][10], int n, int e );
                 void DispAdj(ALGragh *G);
                 void DFS(int v, int flag);
                 void DFS1(int v); //深度优先 非递归
                 void BFS(int v);
private :
                 AdjList adjlist;     //邻接表
                 int n,e;
};


输出:


2017-02-15 16:37:00 weixin_30237281 阅读数 12
  • 数据结构与算法C/C++实现)视频教程

    C/C++实现数据结构与算法视频培训课程全面介绍计算机行业,基本的数据结构与算法,既有理论的深度也有实战的技法。课程全程讲师手敲代码,一步步代你走进数据结构与算法。 本课程涉及的数据结构与算法有,栈,队列,单向链表,双向循环链表,树,二叉树,搜索二叉树,平衡搜索二叉树,冒泡,选择,直插,希尔,,归并等,课程还涉及深度优先算法与广度优先算法等等。

    3582 人正在学习 去看看 王桂林

1.2.1 传值参数

设计一个函数用来计算表达式a+b*c,其中a,b和C是整数,结果也是整数。

程序1-1,计算一个整型表达式

#include <iostream>
using namespace std;

int abc(int a, int b, int c)
{
    return a + b * c;
}

int main()
{
    cout << abc(2, 3, 4) << endl;
    return 0;
}

 a,b,c是函数abc的形参,也是传值参数。

1.2.2 函数模版

设计一个函数用来计算表达式a+b*c,其中a,b和C是浮点型,结果也是浮点型。

程序1-2,计算一个浮点型表达式

#include <iostream>
using namespace std;

float abc(float a, float b, float c)
{
    return a + b * c;
}

int main()
{
    cout << abc(2.1, 3.2, 4.0) << endl;
    return 0;
}

程序1-1和程序1-2都是计算一个类似的表达式,形参类型不同。

与其对每一种可能的形参类型都编写一个相应函数的新版本,不如写一段通用代码。参数类型为一个变量,它的值由编译器来确定。

这种代码使用的是模版语句,如程序1-3所示。

程序1-3,利用模版函数计算一个表达式

#include <iostream>
using namespace std;
template<class T>

T abc(T a, T b, T c)
{
    return a + b * c;
}

int main()
{
    cout << abc(2.1, 3.2, 4.0) << endl;
    return 0;
}

 

1-3程序也只是能满足形参类型为T的计算方式。T为int型满足程序1-1的情况,为float型则满足程序1-2的情况。

设计一个更通用的版本

程序1-1-1

#include <iostream>
using namespace std;
template<class Ta,class Tb, class Tc>

Ta abc(Ta a, Tb b, Tc c)
{
    return a + b * c;
}

int main()
{
    cout << abc(2, 3.2, 4) << endl;
    return 0;
}

注:在新的版本中,每个形参可以是不同的数据类型,而函数返回值的类型与第一个形参类型相同。

1.2.3引用参数

程序1-3使用的形参会增加程序的运行时间。

当a,b,c是传值参数时,一进入函数调用,类型T的复制构造函数便把相应的实参分别复制给形参a,b,c。当函数返回时,类型T的析构函数被启用,以释放形式参数a,b,c的空间。

假定T是用户自定义数据类型且元素数据较多,使得复制和释放所用的时间则交大。

为节省传值参数在参数复制和释放空间时所需要的时间,使用引用参数表达式。

程序1-4 利用引用参数计算一个表达式

T abc(T &a, T &b, T &c)
{
    return a + b * c;
}

1.2.4 常量引用参数

C++提供了另一种参数传递模式-常量引用。该模式指明的引用参数不能被函数修改。

程序1-5 利用常量引用参数计算一个表达式

T abc(const T &a, const T &b,const T &c)
{
    return a + b * c;
}

用关键字const 来指明函数不可修改的引用参数。

可以设计一个更通用的版本。

程序1-6 

template<class Ta,class Tb b,class Tc c>

Ta abc(const Ta &a, const Tb &b,const Tc &c)
{
    return a + b * c;
}

1.2.5 返回值

一个函数可以返回一个值、一个引用或一个常量引用。前面的例子都是返回一个值。在这种情况下,返回的对象被复制到调用环境中。对于函数abc的所有版本来说,这中复制过程都是必要的。因为函数所计算出的表达式结果被存储在一个局部的临时变量中,当函数结束时,这个临时变量所占用的空间将被释放。为了不丢失这个值,在释放临时变量、局部变量以及传值参数的空间之前,要把这个值从临时变量复制到调用函数的环境中去。

给函数返回类型增加一个后缀&,我们便指定了一个引用返回。

函数头

T& mystery(int i, T&z);

定义了一个函数mystery,它返回的是类型T的一个引用。例如返回语句

return z;

这种返回形式不会把z的值复制到返回环境中。当函数结束时,形参i以及所有局部变量的空间都被释放。因为z仅仅是对一个实参的引用,所以它不受影响。

如果把关键字const加在函数头上,便得到const型引用返回

const T& mystery(int i, T&z);

const 引用返回与引用返回是类似的,不同之处在于,const引用返回在返回调用环境时,必须将值赋给const 常量。

1.2.6 重载函数

一个函数的签名是由这个函数的形参类型以及形参个数确定的。

在程序1-1中,函数abc的签名是(int ,int ,int )。C++可以定义两个或更多的同名函数,但是任何两个同名函数不能有同样的签名。

定义多个同名函数的机制称为函数重载。

转载于:https://www.cnblogs.com/haihai187/p/6401276.html

C/C++电子书列表

阅读数 2562

没有更多推荐了,返回首页