什么是C语言缓冲区溢出漏洞？怎么利用？谁可以提供详细的资料

在C语言中引用外部变量，一般使用extern关键字。举个例子如下：//1.c 中定义一个变量g_aint g_a = 100;//2.c 中定义一个函数输出g_a#include <stdio.h>extern int g_a; //这里需要用extern说明g_a是一个外部全局变量void f() { printf("%d ", g_a);}//3.c main函数中调用f()void f(); //声明函数f()int main(){ f();}

u2022 随着 2022 年 3 月 15 日 go 1.18 正式发布，新版本除了对性能的提升之外，还引入了很多新功能，其中就有 go 期盼已久的功能泛型(Generics)，同时还引入的多模块工作区(Workspaces)和模糊测试(Fuzzing)。 u2022 关于泛型网上已经有很多介绍的教程了，这里我介绍一个实用的功能，多模块工作区的使用方法和教程。 u2022 Go 多模块工作区能够使开发者能够更容易地同时处理多个模块的工作，如: u2022 多模块工作区 u2022 开发流程演示 u2022 总结 u2022 参考文献 u2022 go 使用的是多模块工作区，可以让开发者更容易同时处理多个模块的开发。在 Go 1.17 之前，只能使用 go.mod replace 指令来实现，如果你正巧是同时进行多个模块的开发，使用它可能是很痛苦的。每次当你想要提交代码的时候，都不得不删除掉 go.mod 中的 replace 才能使模块稳定的发布版本。 u2022在使用 go 1.18 多模块工作区功能的时候，就使用这项工作变得简单容易处理。下面我来介绍怎么使用这一功能。u2022 Go 多模块工作区文档、代码示例[5] u2022 首先 我们需要 go 1.18 或更高版本 go 安装[6] u2022 通常情况下，建议不要提交 go.work 文件到 git 上，因为它主要用于本地代码开发。 u2022 推荐在: $GOPATH 路径下执行，生成 go.work 文件 u2022 go work init 初始化工作区文件，用于生成 go.work 工作区文件 u2022 go work use 添加新的模块到工作区 u2022 go work edit 用于编辑 go.work 文件 u2022 go work sync 将工作区的构建列表同步到工作区的模块 u2022 go env GOWORK u2022 文件结构和 go.mod 文件结构类似，支持 Go 版本号、指定工作区和需要替换的仓库 u2022文件结构示例: u2022 可以使用 go work use hello 添加模块，也可以手动修改 go.work 工作区添加新的模块 u2022在工作区中添加了模块路径，编译的时候会自动使用 use 中的本地代码进行代码编译，和 replaces 功能类似。 u2022 replaces 命令与 go.mod 指令相同，用于替换项目中依赖的仓库地址 u2022需要注意的是 replaces 和 use 不能同时指定相同的本地路径 u2022 错误示例 u2022 在同时使用 go.work 和 go.mod replace 功能的的时候分别指定不同的代码仓库路径， go.work 优先级高于 go.mod 中定义 u2022 在代码构建时候使用的是 go.work 指定的 example1 仓库的代码， go.work 优先级别更高 u2022 在 Go 1.18 go run 和 go build 都会默认使用工作区功能 u2022 GOWORK 也可以指定配置 go.work 文件位置 u2022 Go 全局变量 GOWORK 设置 off 则可以禁用工作区功能 u2022 演示如何使用多模块工作区功能。在现在微服务盛行的年代，一个人会维护多个代码仓库，很多的时候是多个仓库进行同时开发 u2022 假设我们现在进行 hello 仓库开发，实现的功能是，实现将输入的字符串反转并输出，字符串反转功能依赖于 github.com/link1st/example (下文统称 example )公共仓库实现 u2022 新建 hello 项目 u2022 main.go 代码 u2022 运行代码 go run main.go -str "hello world" 或 go run github.com/link1st/link1st/workspaces/hello -str "hello world" 可以看到输出了 hello world 反转以后的字符串 u2022 到这里，最初的功能已经完成，但是后续需求变动，不仅需要输出反转以后的字符串，还需要将字符串大写 u2022 我们则需要去 example 仓库中添加开发 将字符串大写的功能 u2022 vim example/stringutil/to_upper.go 代码如下 u2022 由于代码还在本地调试，未提交 git 仓库中，这个时候就需要用到 Go 多模块工作区的功能了。 u2022 进入项目根目录，初始化我们现在正在开发的模块 u2022 文件结构如下 u2022 回到 hello 项目， vim main.go 将字符串大写的功能添加上。 u2022 运行代码 u2022 到这里，演示的代码已经全部完成 u2022 使用 Go 多模块工作区的功能，可以让我们轻松在多个模块之间切换工作，更能适应现代微服务架构开发。 [1] Go 1.18 新特性多模块工作区教程: https://github.com/link1st/link1st/tree/master/workspaces [2] Go 1.18 is released!: https://go.dev/blog/go1.18 [3] Tutorial: Getting started with multi-module workspaces: https://go.dev/doc/tutorial/workspaces [4] go-1.18-features: https://sebastian-holstein.de/post/2021-11-08-go-1.18-features/

expvar 包是 Golang 官方提供的公共变量包，它可以辅助调试全局变量。支持一些常见的类型： float64 、 int64 、 Map 、 String 。如果我们的程序要用到上面提的四种类型（其中，Map 类型要求 Key 是字符串）。可以考虑使用这个包。 这些基础的功能就不多说了，大家可以直接看官方的 文档 。 看源码的时候发现一个非常有意思的调试接口， /debug/vars 会把所有注册的变量打印到接口里面。这个接口很有情怀。 感觉这个包还是针对简单变量，比如整形、字符串这种比较好用。 看到就写了，并没有什么沉淀，写得挺乱的。这个包很简单，但是里面还是有些可以借鉴的编码和设计。新版本的 Golang 已经能解析整形为 Key 的哈希表了，这个包啥时候能跟上支持一下？

函数AddUpper会返回一个函数（即函数AddUpper的返回类型是一个函数），当调用这个返回的函数时，需要向它传递一个int变量作为参数，同时，这个函数也会返回一个int类型的值，这个值等于AddUpper的局部变量n先加上x，再返回n。 所以，当执行f:=AddUpper()时，实际上就是将调用AddUpper()后的返回值赋给了f。而前面说了，AddUpper是会返回一个函数的（AddUpper返回的函数的原型是通过func(int) int来限定的）。所以，f实际上就是一个函数，它的签名就是func(int) int，即调用f时需要传递一个int类型的参数，同时f也会返回一个整数。当调用f(1)时，会执行以下代码：n=n+xreturn n而n是外围函数AddUpper的局部变量，初始值是10，x就是你调用f(1)时传入的参数1。所以，执行n=n+x后，n变成了11，然后返回n（11）。所以，f(1)的结果就是11。当接着调用f(2)时，执行的代码还是一样的，都是：n=n+xreturn n只不过n现在是11（因为调用f(1)时，改变了n，从10变成了11），而x是2。所以，f(2)的结果就是13，同时，调用f(2)后n也成了13。

将数组参数作为指针传递即可：第一种方法是传递指针arr := []int{1,2,3}调用方法：foo(&arr)函数定义：func foo(arr *[]int) { /*...*/}第二种方法是用函数的返回值func foo(arr []int) []int {/*修改数组后再返回此数组*/}调用：arr = foo(arr)

编写过C语言程序的肯定知道通过malloc()方法动态申请内存，其中内存分配器使用的是glibc提供的ptmalloc2。 除了glibc，业界比较出名的内存分配器有Google的tcmalloc和Facebook的jemalloc。二者在避免内存碎片和性能上均比glic有比较大的优势，在多线程环境中效果更明显。 Golang中也实现了内存分配器，原理与tcmalloc类似，简单的说就是维护一块大的全局内存，每个线程(Golang中为P)维护一块小的私有内存，私有内存不足再从全局申请。另外，内存分配与GC（垃圾回收）关系密切，所以了解GC前有必要了解内存分配的原理。 为了方便自主管理内存，做法便是先向系统申请一块内存，然后将内存切割成小块，通过一定的内存分配算法管理内存。 以64位系统为例，Golang程序启动时会向系统申请的内存如下图所示： 预申请的内存划分为spans、bitmap、arena三部分。其中arena即为所谓的堆区，应用中需要的内存从这里分配。其中spans和bitmap是为了管理arena区而存在的。 arena的大小为512G，为了方便管理把arena区域划分成一个个的page，每个page为8KB,一共有512GB/8KB个页； spans区域存放span的指针，每个指针对应一个page，所以span区域的大小为(512GB/8KB)乘以指针大小8byte = 512M bitmap区域大小也是通过arena计算出来，不过主要用于GC。 span是用于管理arena页的关键数据结构，每个span中包含1个或多个连续页，为了满足小对象分配，span中的一页会划分更小的粒度，而对于大对象比如超过页大小，则通过多页实现。 根据对象大小，划分了一系列class，每个class都代表一个固定大小的对象，以及每个span的大小。如下表所示： 上表中每列含义如下： class： class ID，每个span结构中都有一个class ID, 表示该span可处理的对象类型 bytes/obj：该class代表对象的字节数 bytes/span：每个span占用堆的字节数，也即页数乘以页大小 objects: 每个span可分配的对象个数，也即（bytes/spans）/（bytes/obj）waste bytes: 每个span产生的内存碎片，也即（bytes/spans）%（bytes/obj）上表可见最大的对象是32K大小，超过32K大小的由特殊的class表示，该class ID为0，每个class只包含一个对象。 span是内存管理的基本单位,每个span用于管理特定的class对象, 跟据对象大小，span将一个或多个页拆分成多个块进行管理。src/runtime/mheap.go:mspan定义了其数据结构： 以class 10为例，span和管理的内存如下图所示： spanclass为10，参照class表可得出npages=1,nelems=56,elemsize为144。其中startAddr是在span初始化时就指定了某个页的地址。allocBits指向一个位图，每位代表一个块是否被分配，本例中有两个块已经被分配，其allocCount也为2。next和prev用于将多个span链接起来，这有利于管理多个span，接下来会进行说明。 有了管理内存的基本单位span，还要有个数据结构来管理span，这个数据结构叫mcentral，各线程需要内存时从mcentral管理的span中申请内存，为了避免多线程申请内存时不断的加锁，Golang为每个线程分配了span的缓存，这个缓存即是cache。src/runtime/mcache.go:mcache定义了cache的数据结构 alloc为mspan的指针数组，数组大小为class总数的2倍。数组中每个元素代表了一种class类型的span列表，每种class类型都有两组span列表，第一组列表中所表示的对象中包含了指针，第二组列表中所表示的对象不含有指针，这么做是为了提高GC扫描性能，对于不包含指针的span列表，没必要去扫描。根据对象是否包含指针，将对象分为noscan和scan两类，其中noscan代表没有指针，而scan则代表有指针，需要GC进行扫描。mcache和span的对应关系如下图所示： mchache在初始化时是没有任何span的，在使用过程中会动态的从central中获取并缓存下来，跟据使用情况，每种class的span个数也不相同。上图所示，class 0的span数比class1的要多，说明本线程中分配的小对象要多一些。 cache作为线程的私有资源为单个线程服务，而central则是全局资源，为多个线程服务，当某个线程内存不足时会向central申请，当某个线程释放内存时又会回收进central。src/runtime/mcentral.go:mcentral定义了central数据结构： lock: 线程间互斥锁，防止多线程读写冲突 spanclass : 每个mcentral管理着一组有相同class的span列表 nonempty: 指还有内存可用的span列表 empty: 指没有内存可用的span列表 nmalloc: 指累计分配的对象个数线程从central获取span步骤如下： 将span归还步骤如下： 从mcentral数据结构可见，每个mcentral对象只管理特定的class规格的span。事实上每种class都会对应一个mcentral,这个mcentral的集合存放于mheap数据结构中。src/runtime/mheap.go:mheap定义了heap的数据结构： lock： 互斥锁 spans: 指向spans区域，用于映射span和page的关系 bitmap：bitmap的起始地址 arena_start: arena区域首地址 arena_used: 当前arena已使用区域的最大地址 central: 每种class对应的两个mcentral 从数据结构可见，mheap管理着全部的内存，事实上Golang就是通过一个mheap类型的全局变量进行内存管理的。mheap内存管理示意图如下： 系统预分配的内存分为spans、bitmap、arean三个区域，通过mheap管理起来。接下来看内存分配过程。 针对待分配对象的大小不同有不同的分配逻辑： (0, 16B) 且不包含指针的对象： Tiny分配 (0, 16B) 包含指针的对象：正常分配 [16B, 32KB] : 正常分配 (32KB, -) : 大对象分配其中Tiny分配和大对象分配都属于内存管理的优化范畴，这里暂时仅关注一般的分配方法。 以申请size为n的内存为例，分配步骤如下： Golang内存分配是个相当复杂的过程，其中还掺杂了GC的处理，这里仅仅对其关键数据结构进行了说明，了解其原理而又不至于深陷实现细节。1、Golang程序启动时申请一大块内存并划分成spans、bitmap、arena区域 2、arena区域按页划分成一个个小块。 3、span管理一个或多个页。 4、mcentral管理多个span供线程申请使用 5、mcache作为线程私有资源，资源来源于mcentral。

查看js相关文档，常有关于全局变量和局部变量的描述，作用域 和c++，go，等语言的概念不太相同。js中关于全局变量的描述通常指的是，在同一个js模块文件中，可以访问。而c++，go等项目，全局变量通常指的是，整个项目可以访问。 所以容易导致理解上的偏差。在定义模块，使用export 导出变量或类后，就可以 在其他 js模块中使用了。 当然了，全局变量，在各语言项目中，应尽量避免使用。如果可以，尽量使用统一的全局模块管理。 --the end

一个简单的流程图1.HTML<div id="myDiagram" style="width:400px; height:150px; background-color: #DAE4E4;"></div>2.$是一个全局变量，全局变量相当于一个画笔，我们先定义一个画笔工具。之后我们就可以通过 $ 符号来调用它自身的一些方法、属性、枚举对象等var $ = go.GraphObject.make;//3.有了画笔，还需要画布，于是我们需要定义一个画布用来装载一些具体内容var myDiagram =$(go.Diagram, //定义的画布"myDiagram",//要渲染的DIV 的Id 名称,1中html中的id{ initialAutoScale: go.Diagram.Uniform, contentAlignment: go.Spot.Center,//对齐方式 layout://画布里的元素布局方式　　　　　　$(go.ForceDirectedLayout,{ 　　defaultSpringLength: 30, 　　defaultElectricalCharge: 100 　　}) });这个画笔可以绘制节点、链接、区域、图案、形状、文本等4.画笔绘制了一个文本对象 go.TextBlock ，并为它填充了属性 text、stroke、font、margin$(go.TextBlock,{

只能写 跳出循环（）

你好，使用golang写动态库，再使用易语言写界面，肯定有不少人有这种想法吧；但中间有些坑，这里留下一些解决方法。一、如何编译？请先安装gcc编译器，选择32位由于易语言只支持32位dll，使用64位会出错，例如找不到此函数；必须先设置两项配置：set GOARCH=386，set CGO_ENABLED=1，用cmd；编译命令：go build -ldflags "-s -w" -buildmode=c-shared -o dlldemo.dll dlldemo.go 。二、形参与返回值在go中，除了 string 特殊外，其他int、bool，等基本类型原本怎样还是怎样；传 string 与返回值 string 都改成 *C.char 类型，其他基本类型不用改；有三个方法比较重要，C.CString 转成c字符串，C.GoString 转成go字符串 ， C.free 释放内存；只要用到 C.CString 此方法，就必须记得释放内存。三、内存泄漏如果使用了 C.CString 却不使用 C.free ，内存暂用只会越来越大，最后奔溃；释放内存时，请不要重复取地址，例如 unsafe.Pointer(&xx变量) ，这样等于没释放；也可能是vc6的原因，使用 defer 在即将出栈时释放，会造成易语言得不到返回值；解决方法，声明全局变量，将结果赋值给全局变量，专门定义一个释放函数例如FreeAll() 用于释放！四、如何调用在填写dll命令时，请在填写，在库中对应命令名时，前面加个 @ ，不然会出现栈错误；每次调用返回值是文本型dll命令时，请都使用前面准备的 FreeAll() 释放内存！通过易语言的便捷，为自己的golang小项目加点gui吧，这里留下源码，给有需要的人。希望能帮到你。

Admin_Culture.asp文件不存在

Golang采用了三色标记法来进行垃圾回收，那么在什么场景下会触发这个回收动作呢？ 源码主要位于文件 src/runtime/mgc.go go version 1.16 触发条件从大方面说，可分为 手动触发 和 系统触发 两种方式。手动触发一般很少用，主要由开发者通过调用 runtime.GC() 函数来实现，而对于系统自动触发是 运行时 根据一些条件判断来进行的，这也正是本文要介绍的内容。 不管哪种触发方式，底层回收机制是一样的，所以我们先看一下手动触发，根据它来找系统触发的条件。 可以看到开始执行GC的是 gcStart() 函数，它有一个 gcTrigger 参数，是一个触发条件结构体，它的结构体也很简单。 其实在Golang 内部所有的GC都是通过 gcStart() 函数，然后指定一个 gcTrigger 的参数来开始的，而手动触发指定的条件值为 gcTriggerCycle 。 gcStart 是一个很复杂的函数，有兴趣的可以看一下源码实现。 对于 kind 的值有三种，分别为 gcTriggerHeap 、 gcTriggerTime 和 gcTriggerCycle 。 运行时会通过 gcTrigger.test() 函数来决定是否需要触发GC，只要满足上面基中一个即可。 到此我们基本明白了这三种触发GC的条件，那么对于系统自动触发这种，Golang 从一个程序的开始到运行，它又是如何一步一步监控到这个条件的呢？ 其实 runtime 在程序启动时，会在一个初始化函数 init() 里启用一个 forcegchelper() 函数，这个函数位于 proc.go 文件。 为了减少系统资源占用，在 forcegchelper 函数里会通过 goparkunlock() 函数主动让自己陷入休眠，以后由 sysmon() 监控线程根据条件来恢复这个gc goroutine。 可以看到 sysmon() 会在一个 for 语句里一直判断这个 gcTriggerTime 这个条件是否满足，如果满足的话，会将 forcegc.g 这个 goroutine 添加到全局队列里进行调度(这里 forcegc 是一个全局变量)。 调度器在调度循环 runtime.schedule 中还可以通过垃圾收集控制器的 runtime.gcControllerState.findRunnabledGCWorker 获取并执行用于后台标记的任务。

释放磁盘空间并且重新运行恢复操作,按照下面的步骤收缩日志。sp_resetstatus关闭数据库的置疑标志，但是原封不动地保持数据库的其它选项。为从根本上解决这样的问题,你可以按下面的操作配置SQLSERVER2000:a.如果不需要恢复到指定的时间点,你可以将数据库的恢复模式配置为简单,这样UPDATE,DELETE,SELECT就不会记录日志,日志就不会增加的很大:USEMASTERGOALTERDATABASEDB_NAMESETRECOVERYSIMPLEb.如果你的恢复模式是全部,你一定要配置日志字段收缩:USEMASTERGOsp_dboption"","trunc.logonchkpt.",truesp_dboption"","autoshrink",truec.通过每日备份将日志收缩:BACKUPDATABASEDATABASE_NAMETOBACKUP_DEVICESBACKUPLOGDATABASE_NAMETOLOG_DEVICESORBACKUPLOGDATABASE_NAMEwithtruncate_only**检查日志的容量:DBCCSQLPERF(LOGSPACE)这时日志并没有收缩!d.每天在备份数据库完成之后,重新启动MSSQLSERVERSERVICE.USEDATABASE_NAMEgoDBCCSHRINKFILE(2,)**检查日志的容量:DBCCSQLPERF(LOGSPACE)这时日志已经收缩!e.手动快速收缩日志:/*runbelowscript,youwillshrinkyoudatabaselogfilesimmediately,inmyexperience,youneedtorunthescriptfor3or4minutesbeforestoppingitmanually*/usedbshrinkfile(2,notruncate)dbshrinkfile(2,)createtablet1(char1char(4000))godeclare@iintselect@i=0while(1=1)beginwhile(@i<100)beginINSERTINTOT1VALUES("A")SELECT@I=@I1ENDTRUNCATEtableT1BACKUPLOG withtruncate_onlyendGO

history.go()和History.back()的区别及应用分类： javascript < input type=button value=刷新 onclick="window.location.reload()" > < input type=button value=前进 onclick="window.history.go(1)" > < input type=button value=后退 onclick="window.history.go(-1)" > < input type=button value=前进 onclick="window.history.forward()" > < input type=button value=后退 onclick="window.history.back()" > 后退+刷新< input type=button value=后退 onclick="window.history.go(-1);window.location.reload()" > JSP 返回上一页的几种方法 1. < a href="javascript:history.back(-1)">返回上一页2. < a href="javascript:;" onClick="javascript:history.back(-1);">返回上一页3.如果是用按钮做的话就是：< input type="button" name="Submit" onclick="javascript:history.back(-1);" value="返回上一页">4.用图片做的话就是：< a href="javascript :;" onClick="javascript :history.back(-1);">< img src="图片路径" border="0" title="返回上一页">< /a>5.< a href="javascript:history.go(-1);">向上一页< /a>, 返回两个页面: history.go(-2);页面跳转:onclick="window.location.href="list.php""6.用js实现页面自动返回到上一页 几秒钟后自动返回上一页代码:（加入两个head间，3000表示3秒）< script type="text/javascript">setTimeout("history.go(-1)", 3000); < /script>< SCRIPT language=javascript>function go(){ window.history.go(-1);}setTimeout("go()",3000);< /SCRIPT>Javascript 返回上一页1. Javascript 返回上一页 history.go(-1), 返回两个页面: history.go(-2);2. history.back().3. window.history.forward()返回下一页4. window.history.go(返回第几页,也可以使用访问过的URL) JavaScript:history.go() 的妙用在Web开发中，会遇到从一页（父页）导向另一页（子页），并且要求“返回”父页的情况，在这里如果用ASP.NET提供的Response.Redirect()方法，往往不会达到理想的效果，例如：返回后，重新加载了页面，无法保存导向子页前的状态，等等，在这里我就介绍一下如何使用JavaScript中history.go()函数来实现返回功能并且保存住状态的方法。 这个函数用起来很简单，只要在页面上加一个html的input元素，例如： < input type="button" value="返回"> 然后再为这个元素添加onclick属性，如： < input type="button" value="返回" onclick="history.go(-1);"> 这样就能达到返回上一页的效果。但是，往往在实践中，并没有这么简单，当你在向服务器提交请求的时候，引起页面回发，你再用history.go(-1)这招就不灵啦，它在这里是返回你回发前的状态，go后面的参数，实际上就是标识你要返回你回发第前n次的状态，所以只要能记住回发了几次，就能用history.go(-n)准确地返回到父页了。 在Web开发中，全局变量也是存不住的，当页面回发后，全局变量的值就会丢失，取而代之的是视图状态，所以我们就只能用视图状态来记录回发的次数了。那么就封装一个视图状态属性把。 public int returnCount { get{ if(ViewState["returnCount"] == null) ViewState["returnCount"] = 0; return (int)ViewState["returnCount"]; } set { ViewState["returnCount"] = value ;} } 定义好这个后，把他放到Page_Load里面，让他每次在页面回发时减1，这样就能准确的记住回发了几次。 protected void Page_Load(object sender, EventArgs e) { returnCount--; //要放在!iIsPostBack之外，要不然就仅仅在页面第一次加载时执行一次，回发时就不执行了。 if(!IsPostBack) { } } 吼吼，到这一步还没完呢，要把我们封装的属性加到Js里面。如下： < input type="button" value="返回" onclick="history.go("< % =returnCount % >");" > 这下就完美了，管你在页面上怎么回发，只要一点这个按钮，肯定会返回到父业的。 注意： 1、如果在本页面上有Response.Redirect()到本页或者类似的情况，那么就要将returnCount作为查询字符串传递一下了，因为这东西在页面失效时就over了。 2、本文仅对非Ajax的Web系统有作用，Ajax的还没仔细研究过javascript:history.go(-1)返回上一页时,网页已过期通常出现网页过期提示都是因为之前发生表单post，对于这种请求方式，浏览器会认为返回的显示内容与提交的数据有关，除非你再次提交数据，否则无法显示。而如果改用get方式提交数据，在IE中，会默认对同一url的get操作，返回的内容相同。出现这种情况我想是因为你的a.jsp是通过之前的post操作显示出来的吧，尝试改成get。如果在详单页面中存在对于数据的更改，在返回时最好不要使用history导航的方式，浏览器是不会去服务器端拿数据的，最好是将url带过来吧，用根据url控制浏览器跳转，get方式在最后记得加上随机时间戳，不然有可能出现数据不更新的情况。解决办法：首先试试back()或go(-2)，若依然不行，则取消禁用页面缓存的限制session_cache_limiter("private,must-revalidate");作用:当session_cache_limiter("private")时，用处是让表单history.go(-1)的时候，填写内容不丢失。go(-2)后再forward(1).为什么我在点击浏览器的后退按钮后，所有字段的信息都被清空了答：这是由于你在你的表单提交页面中使用了 session_start 函数。因为我们后退浏览的是缓存页,而该函数会强制当前页面不被缓存。所以出现了"警告: 网页已经过期!".这些信息,而我们不得不刷新下才能正确显示,对于一个程序人员来说有可能无所谓,但是对于一个internet网上的一个顾客来说,看到该页面,他有可能关闭该页面,而不会去查看这些信息!还有一个原因就是当一个网站流量比较大的时候,缓存是我们程序人员最好的工具,如果失去了这把工具,那么你所在的虚拟服务器必将受到考验!解决办法为，1、不使用session_start()函数。2、在你的 Session_start 函数后加入 header("Cache-control: private"); 注意在本行之前你的PHP程序不能有任何输出。还有基于session的解决方法，在session_start前加上session_cache_limiter("nocache");// 清空表单session_cache_limiter("private"); //不清空表单，只在session生效期间session_cache_limiter("public"); //不清空表单，如同没使用session一般在开发过程中，往往因为表单出错而返回页面的时候填写的信息都不见了，为了支持页面回跳，可以通过两种方法实现。第一，使用Header方法设置消息头Cache-control 引用:header("Cache-control: private, must-revalidate"); //支持页面回跳第二，使用session_cache_limiter方法 session_cache_limiter("private, must-revalidate"); //注意要写在session_start方法之前< meta http-equiv="Cache-Control" CONTENT="private,must-revalidate">

简单减少slave同步延案架构做优化尽量让主库DDL快速执行主库写数据安全性较高比sync_binlog=1innodb_flush_log_at_trx_commit = 1 类设置slave则需要高数据安全完全讲sync_binlog设置0或者关闭binloginnodb_flushlog设置0提高sql执行效率另外使用比主库更硬件设备作slavemysql-5.6.3已经支持线程主复制原理丁奇类似丁奇表做线程Oracle使用数据库(schema)单位做线程同库使用同复制线程sync_binlog=1This makes MySQL synchronize the binary log"s contents to disk each time it commits a transaction默认情况并每写入都binlog与硬盘同步操作系统或机器(仅仅MySQL服务器)崩溃能binlog语句丢 失要想防止种情况使用sync_binlog全局变量(1安全值慢)使binlog每Nbinlog写入与硬盘 同步即使sync_binlog设置1,现崩溃能表内容binlog内容间存致性使用InnoDB表MySQL服务器 处理COMMIT语句整事务写入binlog并事务提交InnoDB两操作间现崩溃重启事务InnoDB滚仍 存binlog用--innodb-safe-binlog选项增加InnoDB表内容binlog间致性(注释：MySQL 5.1需要--innodb-safe-binlog；由于引入XA事务支持该选项作废）该选项提供更程度安全使每事务 binlog(sync_binlog =1)(默认情况真)InnoDB志与硬盘同步该选项效崩溃重启滚事务MySQL服务器binlog剪切滚 InnoDB事务确保binlog反馈InnoDB表确切数据等并使服务器保持与主服务器保持同步(接收 滚语句)innodb_flush_log_at_trx_commit （管用）抱怨Innodb比MyISAM慢 100倍概忘调整值默认值1意思每事务提交或事务外指令都需要志写入（flush）硬盘费特别使用电 池供电缓存（Battery backed up cache）设2于运用特别MyISAM表转意思写入硬盘写入系统缓存志仍每秒flush硬 盘所般丢失超1-2秒更新设0更快点安全面比较差即使MySQL挂能丢失事务数据值2整操作系统 挂才能丢数据

太麻烦了

from Tkinter import*root=Tk()def go(event): global x x=v.get()v=StringVar()e=Entry(root,textvariable=v)e.pack()e.bind("<1>",go)root.mainloop()这里面我用了全局变量global声明了一下，所以x就变成了全局变量，不信的话你可以自己运行试试。print x，我刚才才打的，楼主看看可否

1楼的应该先声明变量f并赋值为1

T-SQL是什么呢

lass A:def go(self):self.one= "sdf"def go1(self):print self.onea = A()a.go()a.go1()sdf ==加了self，以后，这个变量就变成了全局变量，在类中的其他函数中也可以调用。

实例方法可以操作类变量(static变量），也叫类的静态变量。static方法不能操作实例变量。原因很简单，实例变量（或实例方法）是要有类的实例才能访问的，即先要new一个对象，才能访问。而static方法或变量，不需要创建对象，直接通过类名访问，所以它不能访问实例变量。

局部变量，没法调用。

go findrecordno表示把程序的执行转移到 findrecordno这个函数或者过程，他不是个变量。所以，即使你定义为变量了，还是错误的。他是个过程或者函数，也有可能是一个标号。这要看你自己的程序了。

预备知识—程序的内存分配 　　一个由C/C++编译的程序占用的内存分为以下几个部分 　　1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 　　2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。 　　3、全局区（静态区）（static）— 全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。　　4、文字常量区 — 常量字符串就是放在这里的，程序结束后由系统释放 。　　5、程序代码区 — 存放函数体的二进制代码。 例如程序 　　int a = 0; 全局初始化区 　　char *p1; 全局未初始化区 　　main() 　　{ 　　int b; 栈 　　char s[] = "abc"; 栈 　　char *p2; 栈 　　char *p3 = "123456"; 123456在常量区，p3在栈上。 　　static int c =0； 全局（静态）初始化区 　　p1 = (char *)malloc(10); 　　p2 = (char *)malloc(20); 　　} 　　分配得来得10和20字节的区域就在堆区。 　　strcpy(p1, "123456"); 123456放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。所以 你的 new A();是被分到了堆区，具体地址有操作系统分配void Go(){} 的二进制代码是放在程序代码区

一、声名全局变量在全局脚本中声明全局变量，如下：Public gocn2、建立连接，如下：Set gocn = CreateObject("ADODB.Connection")gocn.open "Provider=SQLOLEDB.1;Integrated Security=SSPI;Persist Security Info=False;Initial Catalog=GJS_SY;Data Source=LGL"3、执行代码。例如插入一条记录：gocn.Execute "insert into TB_FJ_DATA(LSH,GKH,T_time) VALUES("1",99,GETDATE( ))"

我的解释在你原句的〔 && Fox_Layman 解释：〕之后。我的答案在每题的后面，原因又在答案的后面。三、阅读程序题1、执行下列程序，当输入A时，写出显示的结果。 ____________Clear && Fox_Layman 解释：清屏Wait "请输入一个字符：" to A && Fox_Layman 解释：Wait，为VFP命令，其作用是：显示信息并暂停 Visual FoxPro 的执行，按任意键或单击鼠标后继续执行。在这里的作用是等待输入，再将键盘输入或鼠标点击后的结果赋值给变量 A。Do Case && Fox_Layman 解释：Do Case ... Endcase 是多路分支语句，是命令集合。作用是若条件满足其中的某一项（某一Case，且排名分先后），即执行该项（Case）下的表达式。 Case Islower(A) && 判别字串A是否以小写开头 && Fox_Layman 解释：有解释了．．．（Case 1） ?"Lower" && Fox_Layman 解释：输出结果〔Lower〕在屏幕上。 Case Isupper(A) && 判别字串A是否以大写开头 && Fox_Layman 解释：有解释了．．．（Case 2） ?"Upper" && Fox_Layman 解释：输出结果〔Upper〕在屏幕上。 Case A>="0" And A<="9" && Fox_Layman 解释：判断是否是数字零到九。（Case 3） ?"Digit" && Fox_Layman 解释：输出结果〔Digit〕在屏幕上。 OtherWise && Fox_Layman 解释：若以上条件都不能满号时，或曰以上各种条件以外的情况时，则．．．（Case 4） ?"Other" && Fox_Layman 解释：输出结果〔Other〕在屏幕上。EndCase && Fox_Layman 解释：多路分支语句结束。*** 本题结果：（屏显）Upper。因为题目有〔当输入A时〕，满足条件（Case 2）。2、执行下列程序，写出显示的结果。 ______________Dimension A(20) && Fox_Layman 解释：声明一个一维数组，并命名该数组名为：A，且指定其行数为：20。Store 1 To A(1), A(2) && Fox_Layman 解释：将数字型数字 1 赋值给第一及第二个元素。For I=3 To 20 && Fox_Layman 解释：循环，范围是从 3 到 20。 A(I)=A(I-1)+A(I-2) && Fox_Layman 解释：将前一个元素（I-1）的值，加上前面的前面的那个元素（I-2）的值，赋给当前元素。即：前两个元素之和等於当前元素。Endfor && Fox_Layman 解释：循环结束。? A(10) && Fox_Layman 解释：将第十个元素的值输出到屏幕。*** 本题结果：（屏显）55。因为：*** 第一个元素的值是：1，由语句〔Store 1 To A(1), A(2)〕产生；*** 第二个元素的值是：1，由语句〔Store 1 To A(1), A(2)〕产生；*** 第三个元素的值是：2，由语句〔A(I)=A(I-1)+A(I-2)〕产生；*** 第四个元素的值是：3，由语句〔A(I)=A(I-1)+A(I-2)〕产生；*** 第五个元素的值是：5，由语句〔A(I)=A(I-1)+A(I-2)〕产生；*** 第六个元素的值是：8，由语句〔A(I)=A(I-1)+A(I-2)〕产生；*** 第七个元素的值是：13，由语句〔A(I)=A(I-1)+A(I-2)〕产生；*** 第八个元素的值是：21，由语句〔A(I)=A(I-1)+A(I-2)〕产生；*** 第九个元素的值是：34，由语句〔A(I)=A(I-1)+A(I-2)〕产生；*** 第十个元素的值是：55，由语句〔A(I)=A(I-1)+A(I-2)〕产生；*** 所以屏显的内容是：55。*** 看出来了没？这是一串斐波那契数列。3、执行下列程序，写出显示的结果。Store 10 To X, Y && Fox_Layman 解释：将数字型数字 10 分别赋值给变量 X 和 Y。Do While .T. && Fox_Layman 解释：循环，条件是循环成立（为真），则一直循环下去。 X=X+1 && Fox_Layman 解释：将变量 X 加 1 之后再赋值给 X。 Do Case && Fox_Layman 解释：Do Case ... Endcase 是多路分支语句，是命令集合。作用参见我在第一题中的解释。 Case Int(X/3)=X/3 && Fox_Layman 解释：变量 X 除以 3 之后取整数的值，等於变量 X 除以 3 之后的值。（Case 1） Loop && Fox_Layman 解释：若条件成立，则跳回到〔Do While .T.〕子句，而不去执行〔Loop〕到〔Enddo〕之间的任何语句。 Case X>=20 && Fox_Layman 解释：变量 X 大於等於 20 时。（Case 2） Exit && Fox_Layman 解释：若条件成立，则跳出本循环。 Otherwise && Fox_Layman 解释：若以上条件都不能满号时，或曰以上各种条件以外的情况时，则．．．（Case 3） Y=Y+X && Fox_Layman 解释：将变量 Y 与变量 X 之和赋值给变量 X。 EndCase && Fox_Layman 解释：多路分支语句结束。Enddo && Fox_Layman 解释：循环结束。?X, Y && Fox_Layman 解释：屏显变量 X 及变量 Y。（注意，要用半角的逗号哟，你在这里用的是全角的逗号）*** 本题结果：（屏显） 20 100。因为：*** 变量 X 及变量 Y 的初始值皆为 10，由语句〔Store 10 To X, Y〕产生；*** 第一次循环时：变量 X 的值为 11，由语句〔X=X+1〕产生；变量 Y 的值为 11+10=21，由语句〔Y=Y+X〕产生，是因为不满足条件（Case 1）或（Case 2），那就只能是（Case 3）；*** 第二次循环时：变量 X 的值为 12，由语句〔X=X+1〕产生；变量 Y 的值仍为 21，因为条件（Case 1）得到了满足，〔Loop〕到〔Enddo〕之间的语句没有被执行；*** 第三次循环时：变量 X 的值为 13，由语句〔X=X+1〕产生；变量 Y 的值为 13+21=34，由语句〔Y=Y+X〕产生，是因为不满足条件（Case 1）或（Case 2），那就只能是（Case 3）；*** 第四次循环时：变量 X 的值为 14，由语句〔X=X+1〕产生；变量 Y 的值为 14+33=48，由语句〔Y=Y+X〕产生，是因为不满足条件（Case 1）或（Case 2），那就只能是（Case 3）；*** 第五次循环时：变量 X 的值为 15，由语句〔X=X+1〕产生；变量 Y 的值仍为 48，因为条件（Case 1）得到了满足，〔Loop〕到〔Enddo〕之间的语句没有被执行；*** 第六次循环时：变量 X 的值为 16，由语句〔X=X+1〕产生；变量 Y 的值为 16+48=64，由语句〔Y=Y+X〕产生，是因为不满足条件（Case 1）或（Case 2），那就只能是（Case 3）；*** 第七次循环时：变量 X 的值为 17，由语句〔X=X+1〕产生；变量 Y 的值为 17+64=81，由语句〔Y=Y+X〕产生，是因为不满足条件（Case 1）或（Case 2），那就只能是（Case 3）；*** 第八次循环时：变量 X 的值为 18，由语句〔X=X+1〕产生；变量 Y 的值仍为 81，因为条件（Case 1）得到了满足，〔Loop〕到〔Enddo〕之间的语句没有被执行；*** 第九次循环时：变量 X 的值为 19，由语句〔X=X+1〕产生；变量 Y 的值为 19+81=100，由语句〔Y=Y+X〕产生，是因为不满足条件（Case 1）或（Case 2），那就只能是（Case 3）；*** 第十次循环时：变量 X 的值为 20，由语句〔X=X+1〕产生；变量 Y 的值仍为 100，因为条件（Case 2）得到了满足，循环已退出。*** 所以屏幕显示的结果是：20, 100。4、执行下列程序，写出显示的结果。Store 0 to X,Y && Fox_Layman 解释：将数字型数字 0 分别赋值给变量 X 和 Y。Do Sub1 && Fox_Layman 解释：调用一个名叫〔Sub1〕的过程。? X,Y,Z && Fox_Layman 解释：屏显变量 X, Y, Z 的值。Procedure Sub1 && Fox_Layman 解释：定义一个名叫〔Sub1〕的过程。Private X && Fox_Layman 解释：声明变量 X 为私有变量。Local Y && Fox_Layman 解释：声明变量 Y 为局部变量。Public Z && Fox_Layman 解释：声明变量 Z 为全局变量。X=1 && Fox_Layman 解释：将 1 赋给变量 X。Y=2 && Fox_Layman 解释：将 2 赋给变量 Y。Z=3 && Fox_Layman 解释：将 3 赋给变量 Z。? X,Y,Z && Fox_Layman 解释：屏显变量 X, Y, Z 的值。Return && Fox_Layman 解释：返回*** 本题结果：*** （第一行屏显） 1 2 3*** （第二行屏显） 0 0 3*** 因为：*** 第一行屏显时，显示的内容为变量 X, Y, Z 在过程 Sub1 中的值，由语句 〔X=1〕、〔Y=2〕和〔Z=3〕得出；*** 第二行屏显时，显示的内容为变量 X, Y, Z 在过程 Sub1 后的值，*** 即： 变量 X 私有变量，它是在调用过程中，把原有的值〔0（零）〕藏了起来，用当前的值〔1〕来参与运行，过程调用完成后，该变量的值又还原成来的值〔0（零）〕，该类型变量的特点是；上下层过程皆不能调用当前值；*** 变量 Y 局部变量，它是在调用过程中，把原有的值〔0（零）〕藏了起来，用当前的值〔2〕来参与运行，过程调用完成后，该变量的值又还原成来的值〔0（零）〕，该类型变量的特点是；上层过程不能调用当前值，但下层过程可以调用当前值；5、当输入数据80时，写出程序的输出结果。 ________________ Clear && Fox_Layman 解释：清屏Store 0 To X,Y && Fox_Layman 解释：将数字型数字 0 分别赋值给变量 X 和 Y。Do While X<10 && Fox_Layman 解释：循环，若条件〔X<10〕成立（为真），则一直循环下去。If Mod(X,5)=0 && Fox_Layman 解释：逻辑表达式，若变量 X 除 5 的余数为〔0（零）〕，即能整除，则．．．Y=Y+X && Fox_Layman 解释：将变量 Y 与变量 X 之和赋值给变量 X。Endif && Fox_Layman 解释：逻辑表达式结束。X=X+1 && Fox_Layman 解释：将变量 X 加 1 之后再赋值给 X。Enddo && Fox_Layman 解释：循环结束。? X,Y && Fox_Layman 解释：屏显变量 X, Y 的值。*** 本题结果：（屏显） 10 5。因为：*** 变量 X 及变量 Y 的初始值皆为 0，由语句〔Store 0 To X, Y〕产生；*** 第一次循环时：变量 X 的值为 1，由语句〔X=X+1〕产生；变量 Y 的值为〔0（零）〕，因为不能满足逻辑表达式〔If Mod(X,5)=0〕；*** 第二次循环时：变量 X 的值为 2，由语句〔X=X+1〕产生；变量 Y 的值为〔0（零）〕，因为不能满足逻辑表达式〔If Mod(X,5)=0〕；*** 第三次循环时：变量 X 的值为 3，由语句〔X=X+1〕产生；变量 Y 的值为〔0（零）〕，因为不能满足逻辑表达式〔If Mod(X,5)=0〕；*** 第四次循环时：变量 X 的值为 4，由语句〔X=X+1〕产生；变量 Y 的值为〔0（零）〕，因为不能满足逻辑表达式〔If Mod(X,5)=0〕；*** 第五次循环时：变量 X 的值为 5，由语句〔X=X+1〕产生；变量 Y 的值为〔0+5=5〕，由语句〔Y=Y+X〕产生，因为能够满足逻辑表达式〔If Mod(X,5)=0〕；*** 第六次循环时：变量 X 的值为 6，由语句〔X=X+1〕产生；变量 Y 的值仍为〔5〕，因为不能满足逻辑表达式〔If Mod(X,5)=0〕；*** 第七次循环时：变量 X 的值为 7，由语句〔X=X+1〕产生；变量 Y 的值仍为〔5〕，因为不能满足逻辑表达式〔If Mod(X,5)=0〕；*** 第八次循环时：变量 X 的值为 8，由语句〔X=X+1〕产生；变量 Y 的值仍为〔5〕，因为不能满足逻辑表达式〔If Mod(X,5)=0〕；*** 第九次循环时：变量 X 的值为 9，由语句〔X=X+1〕产生；变量 Y 的值仍为〔5〕，因为不能满足逻辑表达式〔If Mod(X,5)=0〕；*** 第十次循环时：变量 X 的值为 10，由语句〔X=X+1〕产生；变量 Y 的值仍为〔5〕，因为循环的条件是〔X<10〕，不能满足循环的条件，故循环已退出。*** 所以屏幕显示的结果是：10, 5。*** 另注：〔当输入数据80时〕这句无法实现，因为本程序中没有可供输入的语句，所以无法实现，是不是你哪里搞错了？6、执行下列程序，写出显示的结果。 ________________i=1 && Fox_Layman 解释：将变量 i 赋值 1。DO WHILE i<10 && Fox_Layman 解释：循环，若条件〔i<10〕成立（为真），则一直循环下去。i=i+2 && Fox_Layman 解释：将变量 i 加上 2 之后再赋值给变量 i 。ENDDO && Fox_Layman 解释：循环结束。? i && Fox_Layman 解释：屏显变量 i 的值。*** 本题结果：（屏显） 11。因为：*** 第一次循环时：变量 i 的值为 1+2=3，由语句〔i=i+2〕产生；现在是 i = 3，条件〔i<10〕成立，继续循环；*** 第二次循环时：变量 X 的值为 3+2=5，由语句〔i=i+2〕产生；现在是 i = 5，条件〔i<10〕成立，继续循环；*** 第三次循环时：变量 X 的值为 5+2=7，由语句〔i=i+2〕产生；现在是 i = 7，条件〔i<10〕成立，继续循环；*** 第四次循环时：变量 X 的值为 7+2=9，由语句〔i=i+2〕产生；现在是 i = 9，条件〔i<10〕成立，继续循环；*** 第五次循环时：变量 X 的值为 9+2=11，由语句〔i=i+2〕产生；现在是 i = 11，条件〔i<10〕不成立，结束循环。7、设自由表 成绩（姓名 C 8，语文 I，数学 I，英语 I），窗体如下图所示：命令按钮“确定”的单击事件代码如下：Select max(语文+数学+英语) as 最高分 from 成绩 where 姓名="张" into currsor lsbSelect lsbGo 1Thisform.text1.value=最高分（1） 表格控件要显示学生成绩表中的数据，则应设置该控件的什么属性？（2） 单击“确定”按钮后，文本框Text1中显示的内容是？ 答案：没见到图，不好回答！

那你想咋这必保研里的话，根据你的需求来进行指控就可以了

用户报警信息

.example-btn{color:#fff;background-color:#5cb85c;border-color:#4cae4c}.example-btn:hover{color:#fff;background-color:#47a447;border-color:#398439}.example-btn:active{background-image:none}div.example{width:98%;color:#000;background-color:#f6f4f0;background-color:#d0e69c;background-color:#dcecb5;background-color:#e5eecc;margin:005px0;padding:5px;border:1pxsolid#d4d4d4;background-image:-webkit-linear-gradient(#fff,#e5eecc100px);background-image:linear-gradient(#fff,#e5eecc100px)}div.example_code{line-height:1.4em;width:98%;background-color:#fff;padding:5px;border:1pxsolid#d4d4d4;font-size:110%;font-family:Menlo,Monaco,Consolas,"AndaleMono","lucidaconsole","CourierNew",monospace;word-break:break-all;word-wrap:break-word}div.example_result{background-color:#fff;padding:4px;border:1pxsolid#d4d4d4;width:98%}div.code{width:98%;border:1pxsolid#d4d4d4;background-color:#f6f4f0;color:#444;padding:5px;margin:0}div.codediv{font-size:110%}div.codediv,div.codep,div.example_codep{font-family:"couriernew"}pre{margin:15pxauto;font:12px/20pxMenlo,Monaco,Consolas,"AndaleMono","lucidaconsole","CourierNew",monospace;white-space:pre-wrap;word-break:break-all;word-wrap:break-word;border:1pxsolid#ddd;border-left-width:4px;padding:10px15px}排序算法是《数据结构与算法》中最基本的算法之一。排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。以下是堆排序算法：堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；堆排序的平均时间复杂度为Ο(nlogn)。1.算法步骤创建一个堆H[0??n-1]；把堆首（最大值）和堆尾互换；把堆的尺寸缩小1，并调用shift_down(0)，目的是把新的数组顶端数据调整到相应位置；重复步骤2，直到堆的尺寸为1。2.动图演示代码实现JavaScript实例varlen;//因为声明的多个函数都需要数据长度，所以把len设置成为全局变量functionbuildMaxHeap(arr){//建立大顶堆len=arr.length;for(vari=Math.floor(len/2);i>=0;i--){heapify(arr,i);}}functionheapify(arr,i){//堆调整varleft=2*i+1,right=2*i+2,largest=i;if(left<len&&arr[left]>arr[largest]){largest=left;}if(right<len&&arr[right]>arr[largest]){largest=right;}if(largest!=i){swap(arr,i,largest);heapify(arr,largest);}}functionswap(arr,i,j){vartemp=arr[i];arr[i]=arr[j];arr[j]=temp;}functionheapSort(arr){buildMaxHeap(arr);for(vari=arr.length-1;i>0;i--){swap(arr,0,i);len--;heapify(arr,0);}returnarr;}Python实例defbuildMaxHeap(arr):importmathforiinrange(math.floor(len(arr)/2),-1,-1):heapify(arr,i)defheapify(arr,i):left=2*i+1right=2*i+2largest=iifleft<arrLenandarr[left]>arr[largest]:largest=leftifright<arrLenandarr[right]>arr[largest]:largest=rightiflargest!=i:swap(arr,i,largest)heapify(arr,largest)defswap(arr,i,j):arr[i],arr[j]=arr[j],arr[i]defheapSort(arr):globalarrLenarrLen=len(arr)buildMaxHeap(arr)foriinrange(len(arr)-1,0,-1):swap(arr,0,i)arrLen-=1heapify(arr,0)returnarrGo实例funcheapSort(arr[]int)[]int{arrLen:=len(arr)buildMaxHeap(arr,arrLen)fori:=arrLen-1;i>=0;i--{swap(arr,0,i)arrLen-=1heapify(arr,0,arrLen)}returnarr}funcbuildMaxHeap(arr[]int,arrLenint){fori:=arrLen/2;i>=0;i--{heapify(arr,i,arrLen)}}funcheapify(arr[]int,i,arrLenint){left:=2*i+1right:=2*i+2largest:=iifleft<arrLen&&arr[left]>arr[largest]{largest=left}ifright<arrLen&&arr[right]>arr[largest]{largest=right}iflargest!=i{swap(arr,i,largest)heapify(arr,largest,arrLen)}}funcswap(arr[]int,i,jint){arr[i],arr[j]=arr[j],arr[i]}Java实例publicclassHeapSortimplementsIArraySort{@Overridepublicint[]sort(int[]sourceArray)throwsException{//对arr进行拷贝，不改变参数内容int[]arr=Arrays.copyOf(sourceArray,sourceArray.length);intlen=arr.length;buildMaxHeap(arr,len);for(inti=len-1;i>0;i--){swap(arr,0,i);len--;heapify(arr,0,len);}returnarr;}privatevoidbuildMaxHeap(int[]arr,intlen){for(inti=(int)Math.floor(len/2);i>=0;i--){heapify(arr,i,len);}}privatevoidheapify(int[]arr,inti,intlen){intleft=2*i+1;intright=2*i+2;intlargest=i;if(left<len&&arr[left]>arr[largest]){largest=left;}if(right<len&&arr[right]>arr[largest]){largest=right;}if(largest!=i){swap(arr,i,largest);heapify(arr,largest,len);}}privatevoidswap(int[]arr,inti,intj){inttemp=arr[i];arr[i]=arr[j];arr[j]=temp;}}PHP实例functionbuildMaxHeap(&$arr){global$len;for($i=floor($len/2);$i>=0;$i--){heapify($arr,$i);}}functionheapify(&$arr,$i){global$len;$left=2*$i+1;$right=2*$i+2;$largest=$i;if($left<$len&&$arr[$left]>$arr[$largest]){$largest=$left;}if($right<$len&&$arr[$right]>$arr[$largest]){$largest=$right;}if($largest!=$i){swap($arr,$i,$largest);heapify($arr,$largest);}}functionswap(&$arr,$i,$j){$temp=$arr[$i];$arr[$i]=$arr[$j];$arr[$j]=$temp;}functionheapSort($arr){global$len;$len=count($arr);buildMaxHeap($arr);for($i=count($arr)-1;$i>0;$i--){swap($arr,0,$i);$len--;heapify($arr,0);}return$arr;}C实例#include<stdio.h>#include<stdlib.h>voidswap(int*a,int*b){inttemp=*b;*b=*a;*a=temp;}voidmax_heapify(intarr[],intstart,intend){//建立父__指_和子__指_intdad=start;intson=dad*2+1;while(son<=end){//若子__指_在___才做比_if(son+1<=end&&arr[son]<arr[son+1])//先比___子__大小，__最大的son++;if(arr[dad]>arr[son])//如果父__大於子__代表_整完_，直接跳出函_return;else{//否_交_父子_容再__子__和___比_swap(&arr[dad],&arr[son]);dad=son;son=dad*2+1;}}}voidheap_sort(intarr[],intlen){inti;//初始化，i_最後一_父___始_整for(i=len/2-1;i>=0;i--)max_heapify(arr,i,len-1);//先_第一_元素和已排好元素前一位做交_，再重新_整，直到排序完_for(i=len-1;i>0;i--){swap(&arr[0],&arr[i]);max_heapify(arr,0,i-1);}}intmain(){intarr[]={3,5,3,0,8,6,1,5,8,6,2,4,9,4,7,0,1,8,9,7,3,1,2,5,9,7,4,0,2,6};intlen=(int)sizeof(arr)/sizeof(*arr);heap_sort(arr,len);inti;for(i=0;i<len;i++)printf("%d",arr[i]);printf("");return0;}C++实例#include<iostream>#include<algorithm>usingnamespacestd;voidmax_heapify(intarr[],intstart,intend){//建立父__指_和子__指_intdad=start;intson=dad*2+1;while(son<=end){//若子__指_在___才做比_if(son+1<=end&&arr[son]<arr[son+1])//先比___子__大小，__最大的son++;if(arr[dad]>arr[son])//如果父__大於子__代表_整完_，直接跳出函_return;else{//否_交_父子_容再__子__和___比_swap(arr[dad],arr[son]);dad=son;son=dad*2+1;}}}voidheap_sort(intarr[],intlen){//初始化，i_最後一_父___始_整for(inti=len/2-1;i>=0;i--)max_heapify(arr,i,len-1);//先_第一_元素和已经排好的元素前一位做交_，再_新_整(刚调整的元素之前的元素)，直到排序完_for(inti=len-1;i>0;i--){swap(arr[0],arr[i]);max_heapify(arr,0,i-1);}}intmain(){intarr[]={3,5,3,0,8,6,1,5,8,6,2,4,9,4,7,0,1,8,9,7,3,1,2,5,9,7,4,0,2,6};intlen=(int)sizeof(arr)/sizeof(*arr);heap_sort(arr,len);for(inti=0;i<len;i++)cout<<arr[i]<<"";cout<<endl;return0;}参考文章：https://github.com/hustcc/JS-Sorting-Algorithm/blob/master/7.heapSort.mdhttps://zh.wikipedia.org/wiki/%E5%A0%86%E6%8E%92%E5%BA%8F以下是热心网友对堆排序算法的补充，仅供参考：热心网友提供的补充1：上方又没些C#的堆排序，艾孜尔江补充如下：///<summary>///堆排序///</summary>///<paramname="arr">待排序数组</param>staticvoidHeapSort(int[]arr){intvCount=arr.Length;int[]tempKey=newint[vCount+1];//元素索引从1开始for(inti=0;i<vCount;i++){tempKey[i+1]=arr[i];}//初始数据建堆（从含最后一个结点的子树开始构建，依次向前，形成整个二叉堆）for(inti=vCount/2;i>=1;i--){Restore(tempKey,i,vCount);}//不断输出堆顶元素、重构堆，进行排序for(inti=vCount;i>1;i--){inttemp=tempKey[i];tempKey[i]=tempKey[1];tempKey[1]=temp;Restore(tempKey,1,i-1);}//排序结果for(inti=0;i<vCount;i++){arr[i]=tempKey[i+1];}}///<summary>///二叉堆的重构（针对于已构建好的二叉堆首尾互换之后的重构）///</summary>///<paramname="arr"></param>///<paramname="rootNode">根结点j</param>///<paramname="nodeCount">结点数</param>staticvoidRestore(int[]arr,introotNode,intnodeCount){while(rootNode<=nodeCount/2)//保证根结点有子树{//找出左右儿子的最大值intm=(2*rootNode+1<=nodeCount&&arr[2*rootNode+1]>arr[2*rootNode])?2*rootNode+1:2*rootNode;if(arr[m]>arr[rootNode]){inttemp=arr[m];arr[m]=arr[rootNode];arr[rootNode]=temp;rootNode=m;}else{break;}}}热心网友提供的补充2：堆排序是不稳定的排序！既然如此，每次构建大顶堆时，在父节点、左子节点、右子节点取三者中最大者作为父节点就行。我们追寻的只是最终排序后的结果，所以可以简化其中的步骤。我将个人写的Java代码核心放在下方，有兴趣的同学可以一起讨

有要详解,那我找资料给你吧static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。 被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。 用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。 static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。 static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为： 类名.静态方法名(参数列表...) 类名.静态变量名 用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大，呵呵）。 1、static变量 　按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是： 　对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。 　对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。 所以一般在需要实现以下两个功能时使用静态变量：uf06c 在对象之间共享值时uf06c 方便访问变量时2、静态方法 静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！ 因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。例如为了方便方法的调用，Java API中的Math类中所有的方法都是静态的，而一般类内部的static方法也是方便其它类对该方法的调用。静态方法是类内部的一类特殊方法，只有在需要时才将对应的方法声明成静态的，一个类内部的方法一般都是非静态的 3、static代码块 　static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。例如： public class Test5 { private static int a; private int b; static{ Test5.a=3; System.out.println(a); Test5 t=new Test5(); t.f(); t.b=1000; System.out.println(t.b); } static{ Test5.a=4; System.out.println(a); } public static void main(String[] args) { // TODO 自动生成方法存根 } static{ Test5.a=5; System.out.println(a); } public void f(){ System.out.println("hhahhahah"); } } 运行结果： 3 hhahhahah 1000 4 5 　利用静态代码块可以对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。 4、static和final一块用表示什么 static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！ 对于变量，表示一旦给值就不可修改，并且通过类名可以访问。 对于方法，表示不可覆盖，并且可以通过类名直接访问。有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。 声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制： u2022 它们仅能调用其他的static 方法。 u2022 它们只能访问static数据。 u2022 它们不能以任何方式引用this 或super（关键字super 与继承有关，在下一章中描述）。 如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static 初始化块： // Demonstrate static variables，methods，and blocks. class UseStatic { static int a = 3; static int b; static void meth(int x) { System.out.println("x = " + x); System.out.println("a = " + a); System.out.println("b = " + b); } static { System.out.println("Static block initialized."); b = a * 4; } public static void main(String args[]) { meth(42); } } 一旦UseStatic 类被装载，所有的static语句被运行。首先，a被设置为3，接着static 块执行(打印一条消息)，最后，b被初始化为a*4 或12。然后调用main()，main() 调用meth() ，把值42传递给x。3个println ( ) 语句引用两个static变量a和b，以及局部变量x 。 注意：在一个static 方法中引用任何实例变量都是非法的。 下面是该程序的输出： Static block initialized. x = 42 a = 3 b = 12 在定义它们的类的外面，static 方法和变量能独立于任何对象而被使用。这样，你只要在类的名字后面加点号运算符即可。例如，如果你希望从类外面调用一个static方法，你可以使用下面通用的格式： classname.method( ) 这里，classname 是类的名字，在该类中定义static方法。可以看到，这种格式与通过对象引用变量调用非static方法的格式类似。一个static变量可以以同样的格式来访问——类名加点号运算符。这就是Java 如何实现全局功能和全局变量的一个控制版本。 下面是一个例子。在main() 中，static方法callme() 和static 变量b在它们的类之外被访问。 class StaticDemo { static int a = 42; static int b = 99; static void callme() { System.out.println("a = " + a); } } class StaticByName { public static void main(String args[]) { StaticDemo.callme(); System.out.println("b = " + StaticDemo.b); } } 下面是该程序的输出： a = 42 b = 99 static成员是不能被其所在class创建的实例访问的。 如果不加static修饰的成员是对象成员，也就是归每个对象所有的。 加static修饰的成员是类成员，就是可以由一个类直接调用，为所有对象共有的这样可以么？

你汇编工具里没Windows.inc这个文件,或工具没找到

对于 TEXTPTR 函数，只有 text、ntext 和 image 列有效。create procedure Manage_FAQ_Begin@userid int,@id int,@Topicid int,@State varchar(5) output,@Answer text outputasdeclare @noteptr binary(16)select @State = "add"select @noteptr = textptr(@Answer)--writetext @Answer @noteptr "1111111111111111111111111111111111111111111112222222222"go

全局系统钩子的使用。为此，我开发了一个可重用的类库并创建一个相应的示例程序（见下图）。 你可能注意到另外的关于使用系统钩子的文章。本文与之类似但是有重要的差别。这篇文章将讨论在.NET中使用全局系统钩子，而其它文章仅讨论本地系统钩子。这些思想是类似的，但是实现要求是不同的。 二、 背景 如果你对Windows系统钩子的概念不熟悉，让我作一下简短的描述： u30fb一个系统钩子允许你插入一个回调函数-它拦截某些Windows消息(例如，鼠标相联系的消息)。 u30fb一个本地系统钩子是一个系统钩子-它仅在指定的消息由一个单一线程处理时被调用。 u30fb一个全局系统钩子是一个系统钩子-它当指定的消息被任何应用程序在整个系统上所处理时被调用。已有若干好文章来介绍系统钩子概念。在此，不是为了重新收集这些介绍性的信息，我只是简单地请读者参考下面有关系统钩子的一些背景资料文章。如果你对系统钩子概念很熟悉，那么你能够从本文中得到你能够得到的任何东西。 u30fb关于MSDN库中的钩子知识。 u30fbDino Esposito的《Cutting Edge-Windows Hooks in the .NET Framework》。 u30fbDon Kackman的《在C#中应用钩子》。 本文中我们要讨论的是扩展这个信息来创建一个全局系统钩子-它能被.NET类所使用。我们将用C#和一个DLL和非托管C++来开发一个类库-它们一起将完成这个目标。 三、 使用代码 在我们深入开发这个库之前，让我们快速看一下我们的目标。在本文中，我们将开发一个类库-它安装全局系统钩子并且暴露这些由钩子处理的事件，作为我们的钩子类的一个.NET事件。为了说明这个系统钩子类的用法，我们将在一个用C#编写的Windows表单应用程序中创建一个鼠标事件钩子和一个键盘事件钩子。 这些类库能用于创建任何类型的系统钩子，其中有两个预编译的钩子-MouseHook和KeyboardHook。我们也已经包含了这些类的特定版本，分别称为MouseHookExt和KeyboardHookExt。根据这些类所设置的模型，你能容易构建系统钩子-针对Win32 API中任何15种钩子事件类型中的任何一种。另外，这个完整的类库中还有一个编译的HTML帮助文件-它把这些类归档化。请确信你看了这个帮助文件-如果你决定在你的应用程序中使用这个库的话。 MouseHook类的用法和生命周期相当简单。首先，我们创建MouseHook类的一个实例。mouseHook = new MouseHook();//mouseHook是一个成员变量 接下来，我们把MouseEvent事件绑定到一个类层次的方法上。mouseHook.MouseEvent+=new MouseHook.MouseEventHandler(mouseHook_MouseEvent);// ...private void mouseHook_MouseEvent(MouseEvents mEvent, int x, int y){ string msg =string.Format("鼠标事件::(,).",mEvent.ToString(),x,y); AddText(msg);//增加消息到文本框} 为开始收到鼠标事件，简单地安装下面的钩子即可。mouseHook.InstallHook(); 为停止接收事件，只需简单地卸载这个钩子。mouseHook.UninstallHook(); 你也可以调用Dispose来卸载这个钩子。 在你的应用程序退出时，卸载这个钩子是很重要的。让系统钩子一直安装着将减慢系统中的所有的应用程序的消息处理。它甚至能够使一个或多个进程变得很不稳定。因此，请确保在你使用完钩子时一定要移去你的系统钩子。我们确定在我们的示例应用程序会移去该系统钩子-通过在Form的Dispose方法中添加一个Dispose调用。protected override void Dispose(bool disposing) { if (disposing) { if (mouseHook != null) { mouseHook.Dispose(); mouseHook = null; } // ... }} 使用该类库的情况就是如此。该类库中有两个系统钩子类并且相当容易扩充。 四、 构建库 这个库共有两个主要组件。第一部分是一个C#类库-你可以直接使用于你的应用程序中。该类库，反过来，在内部使用一个非托管的C++ DLL来直接管理系统钩子。我们将首先讨论开发该C++部分。接下来，我们将讨论怎么在C#中使用这个库来构建一个通用的钩子类。就象我们讨论C++/C#交互一样，我们将特别注意C++方法和数据类型是怎样映射到.NET方法和数据类型的。 你可能想知道为什么我们需要两个库，特别是一个非托管的C++ DLL。你还可能注意到在本文的背景一节中提到的两篇参考文章，其中并没有使用任何非托管的代码。为此，我的回答是，"对!这正是我写这篇文章的原因"。当你思考系统钩子是怎样实际地实现它们的功能时，我们需要非托管的代码是十分重要的。为了使一个全局的系统钩子能够工作，Windows把你的DLL插入到每个正在运行的进程的进程空间中。既然大多数进程不是.NET进程，所以，它们不能直接执行.NET装配集。我们需要一种非托管的代码代理- Windows可以把它插入到所有将要被钩住的进程中。 首先是提供一种机制来把一个.NET代理传递到我们的C++库。这样，我们用C++语言定义下列函数(SetUserHookCallback)和函数指针(HookProc)。int SetUserHookCallback(HookProc userProc, UINT hookID)typedef void (CALLBACK *HookProc)(int code, WPARAM w, LPARAM l) SetUserHookCallback的第二个参数是钩子类型-这个函数指针将使用它。现在，我们必须用C#来定义相应的方法和代理以使用这段代码。下面是我们怎样把它映射到C#。private static extern SetCallBackResultsSetUserHookCallback(HookProcessedHandler hookCallback, HookTypes hookType)protected delegate void HookProcessedHandler(int code, UIntPtr wparam, IntPtr lparam)public enum HookTypes { JournalRecord = 0, JournalPlayback = 1, // ... KeyboardLL = 13, MouseLL = 14}; 首先,我们使用DllImport属性导入SetUserHookCallback函数，作为我们的抽象基钩子类SystemHook的一个静态的外部的方法。为此，我们必须映射一些外部数据类型。首先，我们必须创建一个代理作为我们的函数指针。这是通过定义上面的HookProcessHandler 来实现的。我们需要一个函数，它的C++签名为(int,WPARAM,LPARAM)。在Visual Studio .NET C++编译器中，int与C#中是一样的。也就是说，在C++与C#中int就是Int32。事情并不总是这样。一些编译器把C++ int作为Int16对待。我们坚持使用Visual Studio .NET C++编译器来实现这个工程，因此，我们不必担心编译器差别所带来的另外的定义。 接下来，我们需要用C#传递WPARAM和LPARAM值。这些确实是指针，它们分别指向C++的UINT和LONG值。用C#来说，它们是指向uint和int的指针。如果你还不确定什么是WPARAM，你可以通过在C++代码中单击右键来查询它，并且选择"Go to definition"。这将会引导你到在windef.h中的定义。//从windef.h:typedef UINT_PTR WPARAM;typedef LONG_PTR LPARAM; 因此，我们选择System.UIntPtr和System.IntPtr作为我们的变量类型-它们分别相应于WPARAM和LPARAM类型，当它们使用在C#中时。现在，让我们看一下钩子基类是怎样使用这些导入的方法来传递一个回叫函数(代理)到C++中-它允许C++库直接调用你的系统钩子类的实例。首先，在构造器中，SystemHook类创建一个到私有方法InternalHookCallback的代理-它匹配HookProcessedHandler代理签名。然后，它把这个代理和它的HookType传递到C++库以使用SetUserHookCallback方法来注册该回叫函数，如上面所讨论的。下面是其代码实现：public SystemHook(HookTypes type){ _type = type; _processHandler = new HookProcessedHandler(InternalHookCallback); SetUserHookCallback(_processHandler, _type);} InternalHookCallback的实现相当简单。InternalHookCallback在用一个catch-all try/catch块包装它的同时仅传递到抽象方法HookCallback的调用。这将简化在派生类中的实现并且保护C++代码。记住，一旦一切都准备妥当，这个C++钩子就会直接调用这个方法。[MethodImpl(MethodImplOptions.NoInlining)]private void InternalHookCallback(int code, UIntPtr wparam, IntPtr lparam){try catch {}} 我们已增加了一个方法实现属性-它告诉编译器不要内联这个方法。这不是可选的。至少，在我添加try/catch之前是需要的。看起来，由于某些原因，编译器在试图内联这个方法-这将给包装它的代理带来各种麻烦。然后，C++层将回叫，而该应用程序将会崩溃。 现在，让我们看一下一个派生类是怎样用一个特定的HookType来接收和处理钩子事件。下面是虚拟的MouseHook类的HookCallback方法实现：protected override void HookCallback(int code, UIntPtr wparam, IntPtr lparam){ if (MouseEvent == null) int x = 0, y = 0; MouseEvents mEvent = (MouseEvents)wparam.ToUInt32(); switch(mEvent) { case MouseEvents.LeftButtonDown: GetMousePosition(wparam, lparam, ref x, ref y); break; // ... } MouseEvent(mEvent, new Point(x, y));} 首先，注意这个类定义一个事件MouseEvent-该类在收到一个钩子事件时激发这个事件。这个类在激发它的事件之前，把数据从WPARAM和 LPARAM类型转换成.NET中有意义的鼠标事件数据。这样可以使得类的消费者免于担心解释这些数据结构。这个类使用导入的 GetMousePosition函数-我们在C++ DLL中定义的用来转换这些值。为此，请看下面几段的讨论。 在这个方法中，我们检查是否有人在听这一个事件。如果没有，不必继续处理这一事件。然后，我们把WPARAM转换成一个MouseEvents枚举类型。我们已小心地构造了MouseEvents枚举来准确匹配它们在C ++中相应的常数。这允许我们简单地把指针的值转换成枚举类型。但是要注意，这种转换即使在WPARAM的值不匹配一个枚举值的情况下也会成功。 mEvent的值将仅是未定义的（不是null，只是不在枚举值范围之内）。为此，请详细分析System.Enum.IsDefined方法。 接下来，在确定我们收到的事件类型后，该类激活这个事件，并且通知消费者鼠标事件的类型及在该事件过程中鼠标的位置。 最后注意，有关转换WPARAM和LPARAM值：对于每个类型的事件，这些变量的值和意思是不同的。因此，在每一种钩子类型中，我们必须区别地解释这些值。我选择用C++实现这种转换，而不是尽量用C#来模仿复杂的C++结构和指针。例如，前面的类就使用了一个叫作GetMousePosition的 C++函数。下面是C++ DLL中的这个方法：bool GetMousePosition(WPARAM wparam, LPARAM lparam, int amp; x, int amp; y) { MOUSEHOOKSTRUCT * pMouseStruct = (MOUSEHOOKSTRUCT *)lparam; x = pMouseStruct->pt.x; y = pMouseStruct->pt.y; return true;} 不是尽量映射MOUSEHOOKSTRUCT结构指针到C#，我们简单地暂时把它回传到C++层以提取我们需要的值。注意，因为我们需要从这个调用中返回一些值，我们把我们的整数作为参考变量传递。这直接映射到C#中的int*。但是，我们可以重载这个行为，通过选择正确的签名来导入这个方法。private static extern bool InternalGetMousePosition(UIntPtr wparam,IntPtr lparam, ref int x, ref int y) 通过把integer参数定义为ref int，我们得到通过C++参照传递给我们的值。如果我们想要的话，我们还可以使用out int。 五、 限制 一些钩子类型并不适合实现全局钩子。我当前正在考虑解决办法-它将允许使用受限制的钩子类型。到目前为止，不要把这些类型添加回该库中，因为它们将导致应用程序的失败(经常是系统范围的灾难性失败)。下一节将集中讨论这些限制背后的原因和解决办法。HookTypes.CallWindowProcedureHookTypes.CallWindowProretHookTypes.ComputerBasedTrainingHookTypes.DebugHookTypes.ForegroundIdleHookTypes.JournalRecordHookTypes.JournalPlaybackHookTypes.GetMessageHookTypes.SystemMessageFilter 六、 两种类型的钩子 在本节中，我将尽量解释为什么一些钩子类型被限制在一定的范畴内而另外一些则不受限制。如果我使用有点偏差术语的话，请原谅我。我还没有找到任何有关这部分题目的文档，因此，我编造了我自己的词汇。另外，如果你认为我根本就不对，请告诉我好了。 当Windows调用传递到SetWindowsHookEx()的回调函数时它们会因不同类型的钩子而被区别调用。基本上有两种情况：切换执行上下文的钩子和不切换执行上下文的钩子。用另一种方式说，也就是，在放钩子的应用程序进程空间执行钩子回调函数的情况和在被钩住的应用程序进程空间执行钩子回调函数的情况。 钩子类型例如鼠标和键盘钩子都是在被Windows调用之前切换上下文的。整个过程大致如下： 1. 应用程序X拥有焦点并执行。 2. 用户按下一个键。 3. Windows从应用程序X接管上下文并把执行上下文切换到放钩子的应用程序。 4. Windows用放钩子的应用程序进程空间中的键消息参数调用钩子回调函数。 5. Windows从放钩子的应用程序接管上下文并把执行上下文切换回应用程序X。 6. Windows把消息放进应用程序X的消息排队。 7. 稍微一会儿之后，当应用程序X执行时，它从自己的消息排队中取出消息并且调用它的内部按键（或松开或按下）处理器。 8. 应用程序X继续执行... 例如CBT钩子(window创建，等等。)的钩子类型并不切换上下文。对于这些类型的钩子，过程大致如下： 1. 应用程序X拥有焦点并执行。 2. 应用程序X创建一个窗口。 3. Windows用在应用程序X进程空间中的CBT事件消息参数调用钩子回调函数。 4. 应用程序X继续执行... 这应该说明了为什么某种类型的钩子能够用这个库结构工作而一些却不能。记住，这正是该库要做的。在上面第4步和第3步之后，分别插入下列步骤： 1. Windows调用钩子回调函数。 2. 目标回调函数在非托管的DLL中执行。 3. 目标回调函数查找它的相应托管的调用代理。 4. 托管代理被以适当的参数执行。 5. 目标回调函数返回并执行相应于指定消息的钩子处理。 第三步和第四步因非切换钩子类型而注定失败。第三步将失败，因为相应的托管回调函数不会为该应用程序而设置。记住，这个DLL使用全局变量来跟踪这些托管代理并且该钩子DLL被加载到每一个进程空间。但是这个值仅在放钩子的应用程序进程空间中设置。对于另外其它情况，它们全部为null。 Tim Sylvester在他的《Other hook types》一文中指出，使用一个共享内存区段将会解决这个问题。这是真实的，但是也如Tim所指出的，那些托管代理地址对于除了放钩子的应用程序之外的任何进程是无意义的。这意味着，它们是无意义的并且不能在回调函数的执行过程中调用。那样会有麻烦的。 因此，为了把这些回调函数使用于不执行上下文切换的钩子类型，你需要某种进程间的通讯。 我已经试验过这种思想-使用非托管的DLL钩子回调函数中的进程外COM对象进行IPC。如果你能使这种方法工作，我将很高兴了解到这点。至于我的尝试，结果并不理想。基本原因是很难针对各种进程和它们的线程(CoInitialize(NULL))而正确地初始化COM单元。这是一个在你可以使用 COM对象之前的基本要求。 我不怀疑，一定有办法来解决这个问题。但是我还没有试用过它们，因为我认为它们仅有有限的用处。例如，CBT钩子可以让你取消一个窗口创建，如果你希望的话。可以想像，为使这能够工作将会发生什么。 1. 钩子回调函数开始执行。 2. 调用非托管的钩子DLL中的相应的钩子回调函数。 3. 执行必须被路由回到主钩子应用程序。 4. 该应用程序必须决定是否允许这一创建。 5. 调用必须被路由回仍旧在运行中的钩子回调函数。 6. 在非托管的钩子DLL中的钩子回调函数从主钩子应用程序接收到要采取的行动。 7. 在非托管的钩子DLL中的钩子回调函数针对CBT钩子调用采取适当的行动。 8. 完成钩子回调函数的执行。 这不是不可能的，但是不算好的。我希望这会消除在该库中的围绕被允许的和受限制的钩子类型所带来的神秘。 七、 其它 u30fb库文档：我们已经包含了有关ManagedHooks类库的比较完整的代码文档。当以"Documentation"构建配置进行编译时，这被经由Visual Studio.NET转换成标准帮助XML。最后，我们已使用NDoc来把它转换成编译的HTML帮助(CHM)。你可以看这个帮助文件，只需简单地在该方案的解决方案资源管理器中点击Hooks.chm文件或通过查找与该文相关的可下载的ZIP文件。 u30fb增强的智能感知：如果你不熟悉Visual Studio.NET怎样使用编译的XML文件(pre-NDoc output)来为参考库的工程增强智能感知，那么让我简单地介绍一下。如果你决定在你的应用程序中使用这个类库，你可以考虑复制该库的一个稳定构建版本到你想参考它的位置。同时，还要把XML文档文件 (SystemHooksManagedHooksinDebugKennedy.ManagedHooks.xml)复制到相同的位置。当你添加一个参考到该库时，Visual Studio.NET将自动地读该文件并使用它来添加智能感知文档。这是很有用的，特别是对于象这样的第三方库。 u30fb单元测试：我相信，所有的库都应有与之相应的单元测试。既然我是一家公司（主要负责针对.NET环境软件的单元测试）的合伙人和软件工程师，任何人不会对此感到惊讶。因而，你将会在名为ManagedHooksTests的解决方案中找到一个单元测试工程。为了运行该单元测试，你需要下载和安装 HarnessIt-这个下载是我们的商业单元测试软件的一个自由的试用版本。在该单元测试中，我对这给予了特殊的注意-在此处，方法的无效参数可能导致 C++内存异常的发生。尽管这个库是相当简单的，但该单元测试确实能够帮助我在一些更为微妙的情况下发现一些错误。 u30fb非托管的/托管的调试：有关混合解决方案（例如，本文的托管的和非托管的代码）最为技巧的地方之一是调试问题。如果你想单步调试该C++代码或在C++代码中设置断点，你必须启动非托管的调试。这是一个Visual Studio.NET中的工程设置。注意，你可以非常顺利地单步调试托管的和非托管的层，但是，在调试过程中，非托管的调试确实严重地减慢应用程序的装载时间和执行速度。 八、 最后警告 很明显，系统钩子相当有力量；然而，使用这种力量应该是有责任性的。在系统钩子出了问题时，它们不仅仅垮掉你的应用程序。它们可以垮掉在你的当前系统中运行的每个应用程序。但是到这种程度的可能性一般是很小的。尽管如此，在使用系统钩子时，你还是需要再三检查你的代码。 我发现了一项可以用来开发应用程序的有用的技术-它使用系统钩子来在微软的虚拟PC上安装你的喜爱的开发操作系统的一个拷贝和Visual Studio.NET。然后，你就可以在此虚拟的环境中开发你的应用程序。用这种方式，当你的钩子应用程序出现错误时，它们将仅退出你的操作系统的虚拟实例而不是你的真正的操作系统。我已经不得不重启动我的真正的OS-在这个虚拟OS由于一个钩子错误崩溃时，但是这并不经常。

当然可以，但只能是同属性的器件

2.如果把@STR的类型改成CHAR或者NCAHR都不可以,没有提示,就显示执行完成,为什么?因为 char 或者 nchar 是 固定长度的字符串， 不是 “可变长度的字符串”3.给@STR赋予值得时候,还必须是SELECT才能定义,SET不可以,而且赋予任何字符都可以执行,为什么？SET 是可以的，具体代码如下：1> declare @str nvarchar(1000), @k int2> SET @str="";3> SET @k=1;4> while(@k<=6)5> begin6> set @str = space(@k-1)7> set @str = @str + "****"8> print @str9> set @k=@k+110> end11> go**** **** **** **** **** ****1>

在C语言中引用外部变量，一般使用extern关键字。举个例子如下：//1.c 中定义一个变量g_aint g_a = 100;//2.c 中定义一个函数输出g_a#include <stdio.h>extern int g_a; //这里需要用extern说明g_a是一个外部全局变量void f() { printf("%d ", g_a);}//3.c main函数中调用f()void f(); //声明函数f()int main(){ f();}

$(go.TextBlock,{click:function(e,obj){console.log(e.Y.$h.bb.key)}},)//加一个点击事件获取点击文本的相关属性，属性中就有你要的text

在C语言中引用外部变量，一般使用extern关键字。举个例子如下： //1.c 中定义一个变量g_a int g_a = 100; //2.c 中定义一个函数输出g_a #include <stdio.h> extern int g_a; //这里需要用extern说明g_a是一个外部全局变量 void f() { printf("%d ", g_a); } //3.c main函数中调用f() void f(); //声明函数f() int main() { f(); }

原型函数(由类的对象调用) testClass.prototype.walk = function(){ //只能访问:全局变量和全局函数 this.where = function(){ alert("Where can we go?"); go(); } var go = function(){ alert("go name:"+name); alert("go add(1,1):"+add(1,1)); } } </script> 下面看看如何调用: <script type="text/javascript"> //获取一个cbs类的实例 var cbs= new testClass(); //调用类的对象属性age alert("age:"+cbs.age); //获取类函数talk的实例 var talk = new testClass.talk(); //调用类函数的实例函数 talk.what(); //获取原型函数walk的实例 var walk = new cbs.walk(); //调用原型函数的实例函数 walk.where(); </script> 很

静态变量可以将静态变量理解为类变量（与对象无关），而实例变量则属于一个特定的对象。静态变量有两种情况：静态变量是基本数据类型，这种情况下在类的外部不必创建该类的实例就可以直接使用静态变量是一个引用。这种情况比较特殊，主要问题是由于静态变量是一个对象的引用，那么必须初始化这个对象之后才能将引用指向它。因此如果要把一个引用定义成static的，就必须在定义的时候就对其对象进行初始化。静态方法与类变量不同，方法（静态方法与实例方法）在内存中只有一份，无论该类有多少个实例，都共用一个方法。静态方法与实例方法的不同主要有：静态方法可以直接使用，而实例方法必须在类实例化之后通过对象来调用。在外部调用静态方法时，可以使用“类名.方法名”或者“对象名.方法名”的形式。实例方法只能使用后面这种方式。静态方法只允许访问静态成员。而实例方法中可以访问静态成员和实例成员。静态方法中不能使用this（因为this是与实例相关的）。

为什么问了两次？再贴上另一篇Thinking:Java中static用法- -Tag： Thinking:Java中s 一、static 请先看下面这段程序： public class Hello{ public static void main(String[] args){ //(1) System.out.println("Hello,world!"); //(2) } } 看过这段程序，对于大多数学过Java 的从来说，都不陌生。即使没有学过Java，而学过其它的高级语言，例如C，那你也应该能看懂这段代码的意思。它只是简单的输出“Hello,world”，一点别的用处都没有，然而，它却展示了static关键字的主要用法。 在1处，我们定义了一个静态的方法名为main，这就意味着告诉Java编译器，我这个方法不需要创建一个此类的对象即可使用。你还得你是怎么运行这个程序吗？一般，我们都是在命令行下，打入如下的命令(加下划线为手动输入)：javac Hello.javajava HelloHello,world! 这就是你运行的过程，第一行用来编译Hello.java这个文件，执行完后，如果你查看当前，会发现多了一个Hello.class文件，那就是第一行产生的Java二进制字节码。第二行就是执行一个Java程序的最普遍做法。执行结果如你所料。在2中，你可能会想，为什么要这样才能输出。好，我们来分解一下这条语句。（如果没有安装Java文档，请到Sun的官方网站浏览J2SE API）首先，System是位于java.lang包中的一个核心类，如果你查看它的定义，你会发现有这样一行：public static final PrintStream out;接着在进一步，点击PrintStream这个超链接，在METHOD页面，你会看到大量定义的方法，查找println，会有这样一行：public void println(String x)。 好了，现在你应该明白为什么我们要那样调用了，out是System的一个静态变量，所以可以直接使用，而out所属的类有一个println方法。静态方法 通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法。如下所示：class Simple{ static void go(){ System.out.println("Go..."); }}public class Cal{ public static void main(String[] args){ Simple.go(); }} 调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。静态变量 静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于final则另当别论了。看下面这段代码：class Value{ static int c=0; static void inc(){ c++; }}class Count{ public static void prt(String s){ System.out.println(s); } public static void main(String[] args){ Value v1,v2; v1=new Value(); v2=new Value(); prt("v1.c="+v1.c+" v2.c="+v2.c); v1.inc(); prt("v1.c="+v1.c+" v2.c="+v2.c); }} 结果如下：v1.c=0 v2.c=0v1.c=1 v2.c=1由此可以证明它们共享一块存储区。static变量有点类似于C中的全局变量的概念。值得探讨的是静态变量的初始化问题。我们修改上面的程序：class Value{ static int c=0; Value(){ c=15; } Value(int i){ c=i; } static void inc(){ c++; }}class Count{ public static void prt(String s){ System.out.println(s); } Value v=new Value(10); static Value v1,v2; static{ prt("v1.c="+v1.c+" v2.c="+v2.c); v1=new Value(27); prt("v1.c="+v1.c+" v2.c="+v2.c); v2=new Value(15); prt("v1.c="+v1.c+" v2.c="+v2.c); } public static void main(String[] args){ Count ct=new Count(); prt("ct.c="+ct.v.c); prt("v1.c="+v1.c+" v2.c="+v2.c); v1.inc(); prt("v1.c="+v1.c+" v2.c="+v2.c); prt("ct.c="+ct.v.c); }}运行结果如下：v1.c=0 v2.c=0v1.c=27 v2.c=27v1.c=15 v2.c=15ct.c=10v1.c=10 v2.c=10v1.c=11 v2.c=11ct.c=11 这个程序展示了静态初始化的各种特性。如果你初次接触Java，结果可能令你吃惊。可能会对static后加大括号感到困惑。首先要告诉你的是，static定义的变量会优先于任何其它非static变量，不论其出现的顺序如何。正如在程序中所表现的，虽然v出现在v1和v2的前面，但是结果却是v1和v2的初始化在v的前面。在static{后面跟着一段代码，这是用来进行显式的静态变量初始化，这段代码只会初始化一次，且在类被第一次装载时。如果你能读懂并理解这段代码，会帮助你对static关键字的认识。在涉及到继

连续赋值（a，变量1，变量2，变量3。。。）变量1，2，3等等必须是相同数据类型，如果为整数型，a可以为0，文本型就为“”，以此类推

都有m文件了，Open 就看呗 补充一下(1) 菜单操作。从MATLAB主窗口的File菜单中选择Open命令，则屏幕出现Open对话框，在Open对话框中选中所需打开的M文件。(2) 命令操作。在MATLAB命令窗口输入命令：edit 文件名，则打开指定的M文件。 (3) 命令按钮操作。单击MATLAB主窗口工具栏上的Open File命令按钮，再从弹出的对话框中选择所需打开的M文件

Session 对象可以使用 Session 对象存储特定用户会话所需的信息。这样，当用户在应用程序的 Web 页之间跳转时，存储在 Session 对象中的变量将不会丢失，而是在整个用户会话中一直存在下去。当用户请求来自应用程序的 Web 页时，如果该用户还没有会话，则 Web 服务器将自动创建一个 Session 对象。当会话过期或被放弃后，服务器将终止该会话。Session 对象最常见的一个用法就是存储用户的首选项。例如，如果用户指明不喜欢查看图形，就可以将该信息存储在 Session 对象中。有关使用 Session 对象的详细信息，请参阅“ASP 应用程序”部分的“管理会话”。注意 会话状态仅在支持 cookie 的浏览器中保留。语法 Session.collection|property|method集合 Contents 包含已用脚本命令添加到会话中的项目。 StaticObjects 包含通过 <OBJECT> 标记创建的并给定了会话作用域的对象。属性 CodePage 将用于符号映射的代码页。 LCID 现场标识。 SessionID 返回用户的会话验证。 Timeout 应用程序会话状态的超时时限，以分钟为单位。方法 Abandon 该方法破坏 Session 对象并释放其资源。事件 global.asa 文件中声明下列事件的脚本。Session_OnEnd Session_OnStart有关以上事件及 global.asa 文件的详细信息, 请参阅 Global.asa 参考.注释 您可以在 Session 对象中存储值。存储在 Session 对象中的信息在会话及会话作用域内有效。下列脚本演示两种类型的变量的存储方式。<% Session("username") = "Janine" Session("age") = 24 %>但是，如果您将对象存储在 Session对象中，而且您使用 VBScript 作为主脚本语言。则必须使用关键字 Set。如下列脚本所示。<% Set Session("Obj1") = Server.CreateObject("MyComponent.class1") %>然后，您就可以在后面的 Web 页上调用 MyComponent.class1 揭示的方法和属性，其调用方法如下：<% Session("Obj1").MyMethod %>也可以通过展开该对象的本地副本并使用下列脚本来调用：<% Set MyLocalObj1 = Session("Obj1") MyLocalObj1.MyObjMethod %>创建有会话作用域的对象的另一种方法是在 global.asa 文件中使用 <OBJECT> 标记。但是不能在 Session 对象中存储内建对象。例如，下面每一行都将返回错误。<% Set Session("var1") = Session Set Session("var2") = Request Set Session("var3") = Response Set Session("var4") = Server Set Session("var5") = Application %>在将对象存储到 Session 对象之前，必须了解它使用的是哪一种线程模型。只有那些标记为“Both”的对象才能存储在没有锁定单线程会话的 Session 对象中。详细信息, 请参阅“创建 ASP 组件”中的“选择线程模型”。若您将一个数组存储在 Session对象中，请不要直接更改存储在数组中的元素。例如，下列的脚本无法运行。<% Session("StoredArray")(3) = "new value" %>这是因为 Session对象是作为集合被实现的。数组元素 StoredArray(3) 未获得新的赋值。而此值将包含在 Application 对象集合中，并将覆盖此位置以前存储的任何信息。我们极力建议您在将数组存储在 Session对象中时，在检索或改变数组中的对象前获取数组的一个副本。在对数组操作时，您应再将数组全部存储在 Session 对象中，这样您所做的任何改动将被存储下来。下列的脚本对此进行演示。---file1.asp--- <% "Creating and initializing the array Dim MyArray() Redim MyArray(5) MyArray(0) = "hello" MyArray(1) = "some other string""Storing the array in the Session object Session("StoredArray") = MyArrayResponse.Redirect("file2.asp") %>---file2.asp--- <% "Retrieving the array from the Session Object "and modifying its second element LocalArray = Session("StoredArray") LocalArray(1) = " there""printing out the string "hello there" Response.Write(LocalArray(0)&LocalArray(1))"Re-storing the array in the Session object "This overwrites the values in StoredArray with the new values Session("StoredArray") = LocalArray %>相关解答：A页面需输入正确的用户名和密码后, 加条语句:session("isLogin")=true 在B页面前判断: if session("isLogin")=false then response.write "未登录" response.en end if这样就可以了登陆后设置： session("user")=用户名在B页面输入： if session("user")="" then Response.write("<script>alert("请登陆！");window.history.go(-1);</scritp>") end if

你可以在call 的 过程代码中加一个条件 ： if 条件 GOTO eeee: 表示在你要执行的地方做标记条件你可以随便表示，例如，设置一个全局变量a,当过程运行后a的值变为1.需要call 另外一个过程，可以在另外一个过程的第一句代码写 if a=1 goto …………

在放一个timer n1 = Format(m Mod 60, "00.") n2 = Format((m 60) Mod 60, "00:") n3 = Format(m 3600, "00:") Label1.Caption =VAL( n3+ l(Label1.Caption 左2))& .....n2 & n1... & n0....

　　形容花香的四字词语： 　　香气四溢：香味向四处飘散，形容很香。 　　香气扑鼻：芬芳的气味不待嗅而自入鼻中。形容芬芳的气味浓郁而四溢。 　　桂馥兰香：桂、兰:两种散发芳香的花;馥:香。形容气味芳香。 　　芬香扑鼻：指香气冲鼻而来，形容很香。 　　国色天香：原形容颜色和香气不同于一般花卉的牡丹花。后也形容女子的美丽。 　　沁人心脾：沁：渗入。原指芳香凉爽的空气或饮料使人感到舒适。也形容诗歌和文章优美动人，给人清新爽朗的感觉。 　　鸟语花香：鸟叫得好听，花开得喷香。形容春天的美好景象。 　　芬芳馥郁：芬芳:指香气;馥:香气;馥郁:香气浓厚。形容香气非常浓。 　　花香四溢：溢:充满而流出来，“四溢”体现了“花香”的程度很深。花的香味在空气中向四处飘洒,形容花香浓郁。 　　丹桂飘香：原指桂树开花，香飘到十里外。现在形容某件事物出名，人人皆知。 　　十里飘香：指方圆十里以内都可以闻到香味，形容劲味十足。 　　香气扑鼻的造句如下： 　　1, 我家有一盆香气扑鼻的水仙花，一簇簇乳白色的花朵开得正旺，给我家增添了清新与雅致。 　　2, 切开瓜，香气扑鼻，有点像奶油味，还带点柠檬的清香。瓜瓤黄黄的，吃到嘴里，甜到心里。把哈密瓜切成小块，再倒进酸奶，可以做成酸甜可口的沙拉;把哈密瓜和牛奶放进搅拌机打碎，还可以做成香甜的哈密瓜奶昔。 　　3, 我闻着苹果，一阵淡淡的香气扑鼻而来。闻着闻着我就想咬一大口下来，真是香气迷人啊!我的同桌蔡灵灵被香气迷得用舌头添苹果皮呢! 　　4, 那满山遍野的槐花，洁白无瑕，香气扑鼻。 　　5, 一阵秋风吹来，树上的桂花都纷纷飘落下来，香气扑鼻，像夏夜里闪闪发光的星星。 　　6, 语文是香气扑鼻的绿茶，让人神清气爽。 　　7, 金门高粱酒名闻遐迩，我就只饮一小杯，已觉香气扑鼻，味道醇正，的确是名不虚传。 　　8, 我走到桂花树下，一阵秋风吹来，树上的桂花都纷纷飘落下来，香气扑鼻，像夏夜里闪闪发光的星星。 　　9, 校园里百花盛开，香气扑鼻。 　　10, 生命是:你期待莲花,长出的却是肥大而香气扑鼻的芒果. 　　丹桂飘香的造句如下： 　　一、在这金秋送爽、丹桂飘香，喜获丰收的季节，当人们还沉浸在举国欢腾的“国庆”氛围之时，又迎来了一年一度的中秋佳节，两节同辉，九州共庆! 　　二、金秋十月，丹桂飘香，我和妈妈在这迷人的季节来到河西公园。天空高远，阳光柔和，蔚蓝的天空上飘着几片薄纱似的白云。耳边响着一阵阵清脆的鸟鸣声，好像是大自然在歌唱。 　　三、秋天，丹桂飘香，金黄而丰腴，是一个五谷收获的季节，也是一个让人思念和期待的季节，秋风秋雨秋意浓，在这充满诗情画意和喜悦的金秋中，最迷人的莫过于中秋夜那一轮挂在天上的明月了。 　　四、丹桂飘香又中秋，花好月圆人长久。秋风送祝福，明月寄相思。举杯邀明月，天涯共此时。欢乐中秋，欢乐人生。 　　五、金秋送爽，丹桂飘香。我们向生活了六年的小学依依不舍地挥手告别，整顿行装，准备进入初中，开始我梦寐以求的中学生活，这是多么令人高兴的事啊! 　　六、夏日，出水芙蓉，睡莲优雅秋天，菊花披金，丹桂飘香冬来，腊梅凌寒，山茶吐红，玉兰莹洁，它们都各具风采，惹人喜爱。特别为人称道的是春花区。 　　七、花好月圆人长久，丹桂飘香又中秋，中秋圆月欢歌声，茗茶美酒敬月宫，皎洁明月千秋照，合家欢聚人长久。 　　八、金秋送爽，丹桂飘香，岁岁重阳，今又重阳，赏高雅之菊，登陡峭之峰，品浓香之酒，忆远方之友，送真心之福：重阳快乐。 　　九、月满中秋乐登楼，丹桂飘香秋水流。快乐嫦娥舒广袖，好运玉兔陪你走。天涯海角思不休，花好月圆人长久。花似锦，月凝眸，又逢佳节，喜上眉头，真心祝福遥相送，愿你心无忧，快乐团圆，幸福长有。 　　十、又是一年秋高气爽的好时节，天高云淡，丹桂飘香，正是赏景好时节。

香飘飘