require "mytestlib" --指定包名称
--在调用时,必须是package.function
print(mytestlib.add(1.0,2.0))
print(mytestlib.sub(20.1,19))
===================================================================================
===================================================================================
===================================================================================
转自:http://cn.cocos2d-x.org/tutorial/show?id=1474
一、Lua堆栈
要理解Lua和C++交互,首先要理解Lua堆栈。
简单来说,Lua和C/C++语言通信的主要方法是一个无处不在的虚拟栈。栈的特点是先进后出。
在Lua中,Lua堆栈就是一个struct,堆栈索引的方式可是是正数也可以是负数,区别是:正数索引1永远表示栈底,负数索引-1永远表示栈顶。如图:
lua的栈类似于以下的定义, 它是在创建lua_State的时候创建的:
TValue stack[max_stack_len] // 欲知内情可以查 lstate.c 的stack_init函数
存入栈的数据类型包括数值, 字符串, 指针, talbe, 闭包等, 下面是一个栈的例子:
执行下面的代码就可以让你的lua栈上呈现图中的情况
lua_pushcclosure(L, func, 0) // 创建并压入一个闭包
lua_createtable(L, 0, 0) // 新建并压入一个表
lua_pushnumber(L, 343) // 压入一个数字
lua_pushstring(L, “mystr”) // 压入一个字符串
这里要说明的是, 你压入的类型有数值, 字符串, 表和闭包[在c中看来是不同类型的值], 但是最后都是统一用TValue这种数据结构来保存的:), 下面用图简单的说明一下这种数据结构:
TValue结构对应于lua中的所有数据类型, 是一个{值, 类型} 结构, 这就lua中动态类型的实现, 它把值和类型绑在一起, 用tt记录value的类型, value是一个联合结构, 由Value定义, 可以看到这个联合有四个域, 先说明简单的
p -- 可以存一个指针, 实际上是lua中的light userdata结构
n -- 所有的数值存在这里, 不过是int , 还是float
b -- Boolean值存在这里, 注意, lua_pushinteger不是存在这里, 而是存在n中, b只存布尔
gc -- 其他诸如table, thread, closure, string需要内存管理垃圾回收的类型都存在这里
gc是一个指针, 它可以指向的类型由联合体GCObject定义, 从图中可以看出, 有string, userdata, closure, table, proto, upvalue, thread
从下面的图可以的得出如下结论:
1. lua中, number, boolean, nil, light userdata四种类型的值是直接存在栈上元素里的, 和垃圾回收无关.
2. lua中, string, table, closure, userdata, thread存在栈上元素里的只是指针, 他们都会在生命周期结束后被垃圾回收.
二、堆栈的操作
因为Lua与C/C++是通过栈来通信,Lua提供了C API对栈进行操作。
我们先来看一个最简单的例子:
#include <iostream>
#include <string.h>
using namespace std;
extern "C"
{
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"
}
void main()
{
//1.创建一个state
lua_State *L = luaL_newstate();
//2.入栈操作
lua_pushstring(L, "I am so cool~");
lua_pushnumber(L,20);
//3.取值操作
if( lua_isstring(L,1)){ //判断是否可以转为string
cout<<lua_tostring(L,1)<<endl; //转为string并返回
}
if( lua_isnumber(L,2)){
cout<<lua_tonumber(L,2)<<endl;
}
//4.关闭state
lua_close(L);
return ;
}
可以简单理解为luaL_newstate返回一个指向堆栈的指针,其它看注释应该能懂了吧。
其他一些栈操作:
int lua_gettop (lua_State *L); //返回栈顶索引(即栈长度)
void lua_settop (lua_State *L, int idx); //
void lua_pushvalue (lua_State *L, int idx);//将idx索引上的值的副本压入栈顶
void lua_remove (lua_State *L, int idx); //移除idx索引上的值
void lua_insert (lua_State *L, int idx); //弹出栈顶元素,并插入索引idx位置
void lua_replace (lua_State *L, int idx); //弹出栈顶元素,并替换索引idx位置的值
ua_settop将栈顶设置为一个指定的位置,即修改栈中元素的数量。如果值比原栈顶高,则高的部分nil补足,如果值比原栈低,则原栈高出的部分舍弃。所以可以用lua_settop(0)来清空栈。
三、C++调用Lua
我们经常可以使用Lua文件来作配置文件。类似ini,xml等文件配置信息。现在我们来使用C++来读取Lua文件中的变量,table,函数。
lua和c通信时有这样的约定: 所有的lua中的值由lua来管理, c++中产生的值lua不知道, 类似表达了这样一种意思: "如果你(c/c++)想要什么, 你告诉我(lua), 我来产生, 然后放到栈上, 你只能通过api来操作这个值, 我只管我的世界", 这个很重要, 因为:
"如果你想要什么, 你告诉我, 我来产生"就可以保证, 凡是lua中的变量, lua要负责这些变量的生命周期和垃圾回收, 所以, 必须由lua来创建这些值(在创建时就加入了生命周期管理要用到的簿记信息)
"然后放到栈上, 你只能通过api来操作这个值", lua api给c提供了一套完备的操作界面, 这个就相当于约定的通信协议, 如果lua客户使用这个操作界面, 那么lua本身不会出现任何"意料之外"的错误.
"我只管我的世界"这句话体现了lua和c/c++作为两个不同系统的分界, c/c++中的值, lua是不知道的, lua只负责它的世界
现在有这样一个hello.lua 文件:
str = "I am so cool"
tbl = {name = "shun", id = 20114442}
function add(a,b)
return a + b
end
我们写一个test.cpp来读取它:
#include <iostream>
#include <string.h>
using namespace std;
extern "C"
{
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"
}
void main()
{
//1.创建Lua状态
lua_State *L = luaL_newstate();
if (L == NULL)
{
return ;
}
//2.加载Lua文件
int bRet = luaL_loadfile(L,"hello.lua");
if(bRet)
{
cout<<"load file error"<<endl;
return ;
}
//3.运行Lua文件
bRet = lua_pcall(L,0,0,0);
if(bRet)
{
cout<<"pcall error"<<endl;
return ;
}
//4.读取变量
lua_getglobal(L,"str");
string str = lua_tostring(L,-1);
cout<<"str = "<<str.c_str()<<endl; //str = I am so cool~
//5.读取table
lua_getglobal(L,"tbl");
lua_getfield(L,-1,"name");
str = lua_tostring(L,-1);
cout<<"tbl:name = "<<str.c_str()<<endl; //tbl:name = shun
//6.读取函数
lua_getglobal(L, "add"); // 获取函数,压入栈中
lua_pushnumber(L, 10); // 压入第一个参数
lua_pushnumber(L, 20); // 压入第二个参数
int iRet= lua_pcall(L, 2, 1, 0);// 调用函数,调用完成以后,会将返回值压入栈中,2表示参数个数,1表示返回结果个数。
if (iRet) // 调用出错
{
const char *pErrorMsg = lua_tostring(L, -1);
cout << pErrorMsg << endl;
lua_close(L);
return ;
}
if (lua_isnumber(L, -1)) //取值输出
{
double fValue = lua_tonumber(L, -1);
cout << "Result is " << fValue << endl;
}
//至此,栈中的情况是:
//=================== 栈顶 ===================
// 索引 类型 值
// 4 int: 30
// 3 string: shun
// 2 table: tbl
// 1 string: I am so cool~
//=================== 栈底 ===================
//7.关闭state
lua_close(L);
return ;
}
知道怎么读取后,我们来看下如何修改上面代码中table的值:
// 将需要设置的值设置到栈中
lua_pushstring(L, "我是一个大帅锅~");
// 将这个值设置到table中(此时tbl在栈的位置为2)
lua_setfield(L, 2, "name");
我们还可以新建一个table:
// 创建一个新的table,并压入栈
lua_newtable(L);
// 往table中设置值
lua_pushstring(L, "Give me a girl friend !"); //将值压入栈
lua_setfield(L, -2, "str"); //将值设置到table中,并将Give me a girl friend 出栈
需要注意的是:堆栈操作是基于栈顶的,就是说它只会去操作栈顶的值。
举个比较简单的例子,函数调用流程是先将函数入栈,参数入栈,然后用lua_pcall调用函数,此时栈顶为参数,栈底为函数,所以栈过程大致会是:参数出栈->保存参数->参数出栈->保存参数->函数出栈->调用函数->返回结果入栈。
类似的还有lua_setfield,设置一个表的值,肯定要先将值出栈,保存,再去找表的位置。
再不理解可看如下例子:
lua_getglobal(L, "add"); // 获取函数,压入栈中
lua_pushnumber(L, 10); // 压入第一个参数
lua_pushnumber(L, 20); // 压入第二个参数
int iRet= lua_pcall(L, 2, 1, 0);// 将2个参数出栈,函数出栈,压入函数返回结果
lua_pushstring(L, "我是一个大帅锅~"); //
lua_setfield(L, 2, "name"); // 会将"我是一个大帅锅~"出栈
另外补充一下:
lua_getglobal(L,"var")会执行两步操作:1.将var放入栈中,2.由Lua去寻找变量var的值,并将变量var的值返回栈顶(替换var)。
lua_getfield(L,-1,"name")的作用等价于 lua_pushstring(L,"name") + lua_gettable(L,-2)
lua value 和 c value的对应关系
| c | lua |
nil | 无 | {value=0, tt = t_nil} |
boolean | int 非0, 0 | {value=非0/0, tt = t_boolean} |
number | int/float等 1.5 | {value=1.5, tt = t_number} |
lightuserdata | void*, int*, 各种* point | {value=point, tt = t_lightuserdata} |
string | char str[] | {value=gco, tt = t_string} gco=TString obj |
table | 无 | {value=gco, tt = t_table} gco=Table obj |
userdata | 无 | {value=gco, tt = t_udata} gco=Udata obj |
closure | 无 | {value=gco, tt = t_function} gco=Closure obj |
可以看出来, lua中提供的一些类型和c中是对应的, 也提供一些c中没有的类型. 其中有一些药特别的说明一下:
nil值, c中没有对应, 但是可以通过lua_pushnil向lua中压入一个nil值
注意: lua_push*族函数都有"创建一个类型的值并压入"的语义, 因为lua中所有的变量都是lua中创建并保存的, 对于那些和c中有对应关系的lua类型, lua会通过api传来的附加参数, 创建出对应类型的lua变量放在栈顶, 对于c中没有对应类型的lua类型, lua直接创建出对应变量放在栈顶.
例如: lua_pushstring(L, “string”) lua根据"string"创建一个 TString obj, 绑定到新分配的栈顶元素上
lua_pushcclosure(L,func, 0) lua根据func创建一个 Closure obj, 绑定到新分配的栈顶元素上
lua_pushnumber(L,5) lua直接修改新分配的栈顶元素, 将5赋值到对应的域
lua_createtable(L,0, 0)lua创建一个Tabke obj, 绑定到新分配的栈顶元素上
总之, 这是一个 c value –> lua value的流向, 不管是想把一个简单的5放入lua的世界, 还是创建一个table, 都会导致
1. 栈顶新分配元素 2. 绑定或赋值
还是为了重复一句话, 一个c value入栈就是进入了lua的世界, lua会生成一个对应的结构并管理起来, 从此就不再依赖这个c value
lua value –> c value时, 是通过 lua_to* 族api实现, 很简单, 取出对应的c中的域的值就行了, 只能转化那些c中有对应值的lua value, 比如table就不能to c value, 所以api中夜没有提供 lua_totable这样的接口.
四、Lua调用C++
我们分三个方法实现它。
方法一:直接将模块写入Lua源码中
在Lua中调用C/C++,我们可以将函数写lua.c中,然后重新编译Lua文件。
编译好后是这样子的:(如图)
然后我们可以在lua.c中加入我们自己的函数。函数要遵循规范(可在lua.h中查看)如下:
typedef int (*lua_CFunction) (lua_State *L);
换句话说,所有的函数必须接收一个lua_State作为参数,同时返回一个整数值。因为这个函数使用Lua栈作为参数,所以它可以从栈里面读取任意数量和任意类型的参数。而这个函数的返回值则表示函数返回时有多少返回值被压入Lua栈。(因为Lua的函数是可以返回多个值的)
然后我们在lua.c中加入如下函数:
// This is my function
static int getTwoVar(lua_State *L)
{
// 向函数栈中压入2个值
lua_pushnumber(L, 10);
lua_pushstring(L,"hello");
return 2;
}
在pmain函数中,luaL_openlibs函数后加入以下代码:
//注册函数
lua_pushcfunction(L, getTwoVar); //将函数放入栈中
lua_setglobal(L, "getTwoVar"); //设置lua全局变量getTwoVar
通过查找lua.h
/#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
我们发现之前的注册函数可以这样子写:
lua_register(L,"getTwoVar",getTwoVar);
运行,结果如图:
当然,一般我们不建议去修改别人的代码,更倾向于自己编写独立的C/C++模块,供Lua调用,下面来讲讲如何实现。
方法二:使用静态依赖的方式
1. 新建一个空的win32控制台工程,记得在vc++目录中,把lua中的头文件和lib文件的目录包含进来,然后->链接器->附加依赖项->将lua51.lib和lua5.1.lib也包含进来。
2. 在目录下新建一个avg.lua如下:
avg, sum = average(10, 20, 30, 40, 50)
print("The average is ", avg)
print("The sum is ", sum)
3.新建test.cpp如下:
#include <stdio.h>
extern "C" {
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
/* 指向Lua解释器的指针 */
lua_State* L;
static int average(lua_State *L)
{
/* 得到参数个数 */
int n = lua_gettop(L);
double sum = 0;
int i;
/* 循环求参数之和 */
for (i = 1; i <= n; i++)
{
/* 求和 */
sum += lua_tonumber(L, i);
}
/* 压入平均值 */
lua_pushnumber(L, sum / n);
/* 压入和 */
lua_pushnumber(L, sum);
/* 返回返回值的个数 */
return 2;
}
int main ( int argc, char *argv[] )
{
/* 初始化Lua */
L = lua_open();
/* 载入Lua基本库 */
luaL_openlibs(L);
/* 注册函数 */
lua_register(L, "average", average);
/* 运行脚本 */
luaL_dofile(L, "avg.lua");
/* 清除Lua */
lua_close(L);
/* 暂停 */
printf( "Press enter to exit…" );
getchar();
return 0;
}
执行一下,我们可以得到结果:
大概顺序就是:我们在C++中写一个模块函数,将函数注册到Lua解释器中,然后由C++去执行我们的Lua文件,然后在Lua中调用刚刚注册的函数。
看上去很别扭啊有木有。接下来介绍一下dll调用方式。
方法三:使用dll动态链接的方式
我们先新建一个dll工程,工程名为mLualib。(因此最后导出的dll也为mLualib.dll)
然后编写我们的c++模块,以函数为例,我们先新建一个.h文件和.cpp文件。
h文件如下:(如果你不是很能明白头文件的内容,点击这里:http://blog.csdn.net/shun_fzll/article/details/39078971。)
#pragma once
extern "C" {
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}
#ifdef LUA_EXPORTS
#define LUA_API __declspec(dllexport)
#else
#define LUA_API __declspec(dllimport)
#endif
extern "C" LUA_API int luaopen_mLualib(lua_State *L);//定义导出函数
.cpp文件如下:
#include <stdio.h>
#include "mLualib.h"
static int averageFunc(lua_State *L)
{
int n = lua_gettop(L);
double sum = 0;
int i;
/* 循环求参数之和 */
for (i = 1; i <= n; i++)
sum += lua_tonumber(L, i);
lua_pushnumber(L, sum / n); //压入平均值
lua_pushnumber(L, sum); //压入和
return 2; //返回两个结果
}
static int sayHelloFunc(lua_State* L)
{
printf("hello world!");
return 0;
}
static const struct luaL_Reg myLib[] =
{
{"average", averageFunc},
{"sayHello", sayHelloFunc},
{NULL, NULL} //数组中最后一对必须是{NULL, NULL},用来表示结束
};
int luaopen_mLualib(lua_State *L)
{
luaL_register(L, "ss", myLib);
return 1; // 把myLib表压入了栈中,所以就需要返回1
}
不理解没关系,我们先编译它,然后新建一个lua文件,在lua中我们这样子来调用:(调用之前记得把dll文件复制到lua文件目录下)
require "mLualib"
local ave,sum = ss.average(1,2,3,4,5)//参数对应堆栈中的数据
print(ave,sum) -- 3 15
ss.sayHello() -- hello world!
成功调用了有木有?我们看到了输出信息。
至此都发生了什么呢?梳理一下:
1.我们编写了averageFunc求平均值和sayHelloFunc函数,
2.然后把函数封装myLib数组里面,类型必须是luaL_Reg
3.由luaopen_mLualib函数导出并在lua中注册这两个函数。
那么为什么要这样子写呢?实际上当我们在Lua中:
这样子写的时候,Lua会这么干:
local path = "mLualib.dll"
local f = package.loadlib(path,"luaopen_mLualib") -- 返回luaopen_mLualib函数
f() -- 执行
所以当我们在编写一个这样的模块的时候,编写luaopen_xxx导出函数的时候,xxx最好是和项目名一样(因为项目名和dll一样)。
需要注意的是:函数参数里的lua_State是私有的,每一个函数都有自己的栈。当一个C/C++函数把返回值压入Lua栈以后,该栈会自动被清空。
五、总结
本文不涉及lua语法学习,如果有需要,请移步:http://book.luaer.cn/
相关阅读:
Lua系列教程:在C/C++程序里面嵌入Lua脚本
========================================================================================
========================================================================================
============================================================================================
list支持快速的插入和删除,但是查找费时;
vector支持快速的查找,但是插入费时。
map查找的时间复杂度是对数的,这几乎是最快的,hash也是对数的。
如果我自己写,我也会用二叉检索树,它在大部分情况下可以保证对数复杂度,最坏情况是常数复杂度,而std::map在任何情况下都可以保证对数复杂度,原因是它保证存诸结构是完全二叉检索树,但这会在存诸上牺牲一些时间。
STL 中的 map 内部是平衡二叉树,所以平衡二叉树的性质都具备。查找数据的时间也是对数时间。 vector,在分配内存上一般要比 new 高效的多。
为什么说 hash_map 是对数级的?在不碰撞的情况下,hash_map是所有数据结构中查找最快的,它是常数级的。
如果对问题设计了足够好的hash算法,保证碰撞率很低,hash_map的查找效率无可置疑。
另外,STL的map,它的查找是对数级的,是除hash_map外最高的了,你可以说“也许还有改进余地”,但对于99.9999%的程序员,设计一个比STL map好的map,我执悲观态度。
STL的map有平衡策略(比如红黑树什么的),所以不会退化,不需要考虑数据本身的分布问题。只不过,如果数据本身是排好序的,用vector或heap会明显的快些,因为它们的访问比较简单。
我想没必要怀疑stl::map的查找效率,影响效率最主要的因素是什么?算法,在查找问题上,有什么算法比RB_tree更好吗?至少现在还没有。不否 认你可以通过自己写代码,设计一个符合你需要的BR—TREE,比stl::map简捷那么一点,但最多也就每次迭代中少一行指令而已,处理十万个数据多 执行十万行指令,这对你重要吗?如果你不是在设计OS像LINUX,没人会关注这十万行指令花的时间。
rb-tree的时间花在了插入和删除上,如果你不是对插入和删除效率要求很高,你没有理由不选择基于rb-tree的stl::map。
大多数程序员写不出比std::map更好的map,这是当然的。然而并不是std::map的所有特性都出现在我们的程序中,自己编写的可以更适合自己的程序,的确会比std::map更快一些。
关于hash_map,它与map的实现机制是不一样的,map内部一般用树来实现,其查找操作是O(logN)的,这个没有争议,我就不多说了。
hash_map的查找,内部是通过一个从key到value的运算函数来实现的,这个函数“只接受key作为参数”,也就是说,hash_map的查找 算法与数据量无关,所以认为它是O(1)级的。来这里的应该都是达人,可以参看《数据结构》。当然,事实总不这样完美,再引一段前面我自已说的话,进一步 说明,以免误会:
-----------------------------------------
在不碰撞的情况下,hash_map是所有数据结构中查找最快的,它是常数级的。
------------------------------------------
注意我的前提:“在不碰撞的情况下”,其实换句话说,就是要有足够好的hash函数,它要能使key到value的映射足够均匀,否则,在最坏的情况下,它的计算量就退化到O(N)级,变成和链表一样。
如果说 hash_map 是所有容器中最慢的,也只能说:“最拙劣的hash函数”会使hash_map成为查找最慢的容器。但这样说意义不大,因为,最凑巧的排列能使冒泡排序成为最快的排序算法。
BS: "对于大型容器而言,hash_map能够提供比map快5至10倍的元素查找速度是很常见的,尤其是在查找速度特别重要的地方.另一方面,如果hash_map选择了病态的散列函数,他也可能比map慢得多. "
ANSIC++在1998年之后就没再有重大改变,并且决定不再向C++标准库中做任何重大的变更,正是这个原因,hash table(包括hash_map)并没有被列入标准之中,虽然它理应在C++标准之中占有一席之地。
虽然,现在的大多数编译平台支持hash table,但从可移植性方面考虑,还是不用hash table的好。
hehe俺也来凑凑热闹。
1.有的时候vector可以替代map
比如key是整数,就可以以key的跨度作为长度来定义vector。
数据规模很大的时候,差异是惊人的。当然,空间浪费往往也惊人。
2.hash是很难的东西
没有高效低碰撞的算法,hash_xxx没有意义。
而对不同的类型,数据集,不可能有优良的神仙算法。必须因场合而宜。
俺有的解决方法是GP,可不是饭型,是遗传编程,收效不错。
你的百万级的数据放到vector不大合适。因为vector需要连续的内存空间,显然在初始化这个容器的时候会花费很大的容量。
使用map,你想好了要为其建立一个主键吗?如果没有这样的需求,为什么不考虑deque或者list?
map默认使用的是deque作为容器。其实map不是容器,拿它与容器比较意义不大。因为你可以配置它的底层容器类型。
如果内存不是考虑的问题。用vector比map好。map每插入一个数据,都要排序一次。所以速度反不及先安插所有元素,再进行排序。
用 binary_search对已序区间搜索,如果是随机存取iterator,则是对数复杂度。可见,在不考虑内存问题的情况下,vector比map 好。
如果你需要在数据中间进行插入,list 是最好的选择,vector 的插入效率会让你痛苦得想死。
涉及到查找的话用map比较好,因为map的内部数据结构用rb-tree实现,而用vector你只能用线性查找,效率很低。
stl还提供了 hash容器,理论上查找是飞快~~~。做有序插入的话vector是噩梦,map则保证肯定是按key排序的,list要自己做些事情。
HASH类型的查找肯定快,是映射关系嘛,但是插入和删除却慢,要做移动操作, LIST类型的使链式关系,插入非常快,但是查找却费时,需要遍历~~ , 还是用LIST类型的吧,虽然查找慢点,
先快速排序,然后二分查找,效率也不低
==============================================================================
==============================================================================
==============================================================================
深入理解下 到底什么是hash_map 和lua
比较两种思路的差异
在 2012年07月05日 那天写的 已经有 92865 次阅读了
服务器君一共花费了207.759 ms进行了4次数据库查询,努力地为您提供了这个页面。
究竟要如何反转呢?我们不妨拿一个例子来说明一下算法。
第一次交换
第二次交换
第三次交换
步骤:
- 定义当前结点 current,初始值为首元结点,current = L->next;
- 定义当前结点的后继结点 pnext, pnext = current->next;
- 只要 pnext 存在,就执行以下循环:
- 定义新节点 prev,它是 pnext的后继结点,prev = pnext->next;
- 把pnext的后继指向current, pnext->next = current;
- 此时,pnext 实际上已经到了 current 前一位成为新的current,所以这个时候 current 结点实际上成为新的 pnext,current = pnext;
- 此时,新的 current 就是 pnext,current = pnext;
- 而新的 pnext 就是 prev,pnext = prev;
- 最后将头结点与 current 重新连上即可,L->next = current;
函数设计如下:
02 | Status ListReverse(LinkList L) |
04 | LinkList current,pnext,prev; |
05 | if (L == NULL || L->next == NULL) |
08 | pnext = current->next; |
13 | pnext->next = current; |
16 | printf ( "交换后:current = %d,next = %d \n" ,current->data,current->next->data); |
01 | Status ListReverse2(LinkList L) |
10 | while (current->next != NULL) |
13 | current->next = p->next; |
- p = current->next; p 就相当于前面的 pnext。(图1中a2即为p)
- current->next = p->next; p->next 就相当于 prev的角色,这句代码意思是 current 的后继指向 prev.(相当于图1中a1->next = a3(a2->next))
- p->next = L->next; 这句就是 p 的后继直接指向首元节点。(相当于图1中a2->next = a1)
- L->next = p; 然后再将头结点指向 p。(相当于图1中L->next = a2)
这个是程序运行的结果。
03 | -> 68 -> 55 -> 18 -> 45 -> 41 -> 43 -> 5 -> 28 -> 80 -> 67 |
06 | -> 55 -> 68 -> 18 -> 45 -> 41 -> 43 -> 5 -> 28 -> 80 -> 67 |
08 | -> 18 -> 55 -> 68 -> 45 -> 41 -> 43 -> 5 -> 28 -> 80 -> 67 |
10 | -> 45 -> 18 -> 55 -> 68 -> 41 -> 43 -> 5 -> 28 -> 80 -> 67 |
12 | -> 41 -> 45 -> 18 -> 55 -> 68 -> 43 -> 5 -> 28 -> 80 -> 67 |
14 | -> 43 -> 41 -> 45 -> 18 -> 55 -> 68 -> 5 -> 28 -> 80 -> 67 |
16 | -> 5 -> 43 -> 41 -> 45 -> 18 -> 55 -> 68 -> 28 -> 80 -> 67 |
18 | -> 28 -> 5 -> 43 -> 41 -> 45 -> 18 -> 55 -> 68 -> 80 -> 67 |
20 | -> 80 -> 28 -> 5 -> 43 -> 41 -> 45 -> 18 -> 55 -> 68 -> 67 |
22 | -> 67 -> 80 -> 28 -> 5 -> 43 -> 41 -> 45 -> 18 -> 55 -> 68 |
26 | -> 67 -> 80 -> 28 -> 5 -> 43 -> 41 -> 45 -> 18 -> 55 -> 68 |
最后附上完整代码,反转有两个函数。
- 方法1,current始终保持在第一位,pnext与prev遍历并完成交换。
- 方法2,current始终是原链表的第一个数,然后把pnext不断移动到首位。
008 | #define MAXSIZE 20 /* 存储空间初始分配量 */ |
019 | typedef struct Node *LinkList; |
022 | Status InitList(LinkList *L) |
024 | *L=(LinkList) malloc ( sizeof (Node)); |
035 | int ListLength(LinkList L) |
048 | Status ClearList(LinkList *L) |
064 | Status ListTraverse(LinkList L) |
076 | Status visit(ElemType c) |
084 | Status GetElem(LinkList L, int i,ElemType *e) |
104 | int LocateElem(LinkList L,ElemType e) |
120 | void CreateListHead(LinkList *L, int n) |
125 | *L = (LinkList) malloc ( sizeof (Node)); |
127 | for (i=0; i < n; i++) |
129 | p = (LinkList) malloc ( sizeof (Node)); |
130 | p->data = rand ()%100+1; |
131 | p->next = (*L)->next; |
137 | void CreateListTail(LinkList *L, int n) |
142 | *L = (LinkList) malloc ( sizeof (Node)); |
144 | for (i=0; i < n; i++) |
146 | p = (Node *) malloc ( sizeof (Node)); |
147 | p->data = rand ()%100+1; |
156 | Status ListInsert(LinkList *L, int i,ElemType e) |
169 | s = (LinkList) malloc ( sizeof (Node)); |
178 | Status ListDelete(LinkList *L, int i,ElemType *e) |
184 | while (p->next && j < i) |
189 | if (!(p->next) || j > i) |
199 | Status ListReverse(LinkList L) |
201 | LinkList current,pnext,prev; |
202 | if (L == NULL || L->next == NULL) |
205 | pnext = current->next; |
206 | current->next = NULL; |
210 | pnext->next = current; |
219 | Status ListReverse2(LinkList L) |
228 | while (current->next != NULL) |
231 | current->next = p->next; |
235 | printf ( "current = %d, \n" , current -> data); |
249 | printf ( "链表L初始化完毕,ListLength(L)=%d\n" ,ListLength(L)); |
251 | printf ( "\n1.整表创建(头插法) \n2.整表创建(尾插法) \n3.遍历操作 \n4.插入操作" ); |
252 | printf ( "\n5.删除操作 \n6.获取结点数据 \n7.查找某个数是否在链表中 \n8.置空链表" ); |
253 | printf ( "\n9.链表反转逆序" ); |
254 | printf ( "\n0.退出 \n请选择你的操作:\n" ); |
259 | CreateListHead(&L,10); |
260 | printf ( "整体创建L的元素(头插法):\n" ); |
266 | CreateListTail(&L,10); |
267 | printf ( "整体创建L的元素(尾插法):\n" ); |
278 | printf ( "要在第几个位置插入元素?" ); |
280 | printf ( "插入的元素值是多少?" ); |
282 | ListInsert(&L,pos,value); |
290 | ListDelete(&L,pos,&e); |
291 | printf ( "删除第%d个元素成功,现在链表为:\n" , pos); |
297 | printf ( "你需要获取第几个元素?" ); |
300 | printf ( "第%d个元素的值为:%d\n" , pos, e); |
305 | printf ( "输入你需要查找的数:" ); |
309 | printf ( "第%d个元素的值为%d\n" ,k,pos); |
311 | printf ( "没有值为%d的元素\n" ,pos); |
317 | printf ( "\n清空L后:ListLength(L)=%d\n" ,ListLength(L)); |
延伸阅读
此文章所在专题列表如下:
- 第01话:线性表的概念与定义
- 第02话:线性表的抽象数据类型ADT定义
- 第03话:线性表的顺序存储结构
- 第04话:线性表的初始化
- 第05话:线性表的遍历、插入操作
- 第06话:判断线性表是否为空与置空操作
- 第07话:线性表的查找操作
- 第08话:线性表删除某个元素
- 线性表顺序存储的优缺点
- 线性表链式存储结构的由来与基本概念
- 单链表的头指针、头结点与首元结点
- 单链表的结构体定义与声明
- 单链表的初始化
- 单链表的插入与遍历操作
- 单链表的删除某个元素的操作
- 获取单链表中的指定位置的元素
- 查找某数在单链表中的位置
- 用头插法实现单链表整表创建
- 用尾插法实现单链表整表创建
- 将单链表重置为空表
- 单链表反转/逆序的两种方法
- 单链表反转/逆序的第三种方法
- 求单链表倒数第N个数
- 用标尺法快速找到单链表的中间结点
- 如何判断链表是否有环的存在
- 单链表建环,无环链表变有环
- 删除单链表中的重复元素
======================================================
==========================================================
=========================================================
-
三个进程共享4个互斥资源,则每个进程最多申请多少个资源时,系统不会死锁()?A.1 B.2 C.3 D.4
=============================================================================================================
=============================================================================================================
================================================================================================================
C++中的struct对C中的struct进行了扩充,它已经不再只是一个包含不同数据类型的数据结构了,它已经获取了太多的功能。
struct能包含成员函数吗? 能!
struct能继承吗? 能!!
struct能实现多态吗? 能!!!
最本质的一个区别就是默认的访问控制,体现在两个方面:
1)默认的继承访问权限。struct是public的,class是private的。
写如下的代码:
struct A
{
char a;
};
struct B : A
{
char b;
};
这个时候B是public继承A的。如果都将上面的struct改成class,那么B是private继承A的。这就是默认的继承访问权限。所以我们在平时写类继承的时候,通常会这样写:
struct B : public A
就是为了指明是public继承,而不是用默认的private继承。
当然,到底默认是public继承还是private继承,取决于子类而不是基类。我的意思是,struct可以继承class,同样class也可以继承struct,那么默认的继承访问权限是看子类到底是用的struct还是class。如下:
struct A{};
class B : A{}; //private继承
struct C : B{}; //public继承
2)struct作为数据结构的实现体,它默认的数据访问控制是public的,而class作为对象的实现体,它默认的成员变量访问控制是private的。
3)“class”这个关键字还用于定义模板参数,就像“typename”。但关键字“struct”不用于定义模板参数。
4) 还是上面所说的,C++中的struct是对C中的struct的扩充,既然是扩充,那么它就要兼容过去C中struct应有的所有特性。例如你可以这样写:
struct A //定义一个struct
{
char c1;
int n2;
double db3;
};
A a={'p',7,3.1415926}; //定义时直接赋值
也就是说struct可以在定义的时候用{}赋初值。
向上面的struct中加入一个构造函数(或虚函数),struct也不能用{}赋初值了。的确,以{}的方式来赋初值,只是用一个初始化列表来对数据进行按顺序的初始化,如上面如果写成A a={'p',7};则c1,n2被初始化,而db3没有。这样简单的copy操作,只能发生在简单的数据结构上,而不应该放在对象上。加入一个构造函数或是一个虚函数会使struct更体现出一种对象的特性,而使此{}操作不再有效。事实上,是因为加入这样的函数,使得类的内部结构发生了变化。而加入一个普通的成员函数呢?你会发现{}依旧可用。其实你可以将普通的函数理解成对数据结构的一种算法,这并不打破它数据结构的特性。至于虚函数和普通成员函数有什么区别,我会具体写篇文章讨论。
那么,看到这里,我们发现即使是struct想用{}来赋初值,它也必须满足很多的约束条件,这些条件实际上就是让struct更体现出一种数据机构而不是类的特性。那为什么我们在上面仅仅将struct改成class,{}就不能用了呢?其实问题恰巧是我们之前所讲的——访问控制!你看看,我们忘记了什么?对,将struct改成class的时候,访问控制由public变为private了,那当然就不能用{}来赋初值了。加上一个public,你会发现,class也是能用{}的,和struct毫无区别!!!
从上面的区别,我们可以看出,struct更适合看成是一个数据结构的实现体,class更适合看成是一个对象的实现体。
二、
关于使用大括号初始化
class和struct如果定义了构造函数的话,都不能用大括号进行初始化
如果没有定义构造函数,struct可以用大括号初始化。
如果没有定义构造函数,且所有成员变量全是public的话,可以用大括号初始化。
关于默认访问权限
class中默认的成员访问权限是private的,而struct中则是public的。
关于继承方式
class继承默认是private继承,而struct继承默认是public继承。
且看如下代码(看看编译器给出的错误信息):
class T1
{
public:
void f()
{
cout<<"T1::f()"<<endl;
}
int x,y;
};
struct T2
{
int x;
void f(){cout<<"T2::f()"<<endl;}
};
struct TT1 : T1
{
};
class TT2 : T2
{
};
int main()
{
TT1 t1;
TT2 t2;
t1.f();
t2.f();
}
关于模版
在模版中,类型参数前面可以使用class或typename,如果使用struct,则含义不同,struct后面跟的是“non-type template parameter”,而class或typename后面跟的是类型参数。
template <struct X>
void f(X x)
{
}
//出错信息:d:codecpptestcpptestcpptest.cpp(33) : error C2065: 'X' : undeclared identifier