windows系统复制大文件提示对于目标文件系统过大的解决方案

最新推荐文章于 2022-03-25 16:25:22 发布
最新推荐文章于 2022-03-25 16:25:22 发布
阅读量1.3w 收藏 11
点赞数 9
分类专栏： 计算机硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42249896/article/details/89017833
版权

问题场景：

当我们把一个大文件或压缩移入到一个盘（u盘或硬盘）里，提示对于目标文件系统过大无法移动，就是该盘的文件系统导致的，转换为NTFS即可！

方案一（建议使用）：

1、windows+R来打开cmd命令行：
在这里插入图片描述
2、输入convert H:/fs:ntfs（其中H指的是U盘或硬盘的盘符：我的是H盘）
在这里插入图片描述
3、转换成功：
在这里插入图片描述

方案二（不建议使用）：

选择盘符并右击：
在这里插入图片描述
在这里插入图片描述
选择相应的NTFS文件系统然后在进行格式化：
在这里插入图片描述

光头强儿
关注
  • 9
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
U盘复制移动文件时对于目标文件系统过大解决方法
08-14
有时候在复制一个文件到U盘的时候，突然弹出了‘对于目标文件系统过大’的对话框，下面附上解决两种方案
【Windows 问题系列第 6 篇】】大文件无法移动到U盘如何解决
“Allen Su”的博客
07-13 3909
想要把一个大文件拷贝到U盘，明明 U盘 里面还有相当大的容量，可拷贝时总提示“文件太大”无法传输，今天教大家如何往U盘里面拷贝大文件。
操作系统(内存管理)
09-20
文将对 Linux™ 程序员可以使用的内存管理技术进行概述，虽然关注的重点是 C 语言，但同样也适用于其他语言。文中将为您提供如何管理内存的细节，然后将进一步展示如何手工管理内存，如何使用引用计数或者内存池来半手工地管理内存，以及如何使用垃圾收集自动管理内存。 为什么必须管理内存 内存管理是计算机编程最为基本的领域之一。在很多脚本语言中，您不必担心内存是如何管理的，这并不能使得内存管理的重要性有一点点降低。对实际编程来说，理解您的内存管理器的能力与局限性至关重要。在大部分系统语言中，比如 C 和 C++，您必须进行内存管理。本文将介绍手工的、半手工的以及自动的内存管理实践的基本概念。 追溯到在 Apple II 上进行汇编语言编程的时代，那时内存管理还不是个大问题。您实际上在运行整个系统。系统有多少内存，您就有多少内存。您甚至不必费心思去弄明白它有多少内存，因为每一台机器的内存数量都相同。所以，如果内存需要非常固定，那么您只需要选择一个内存范围并使用它即可。 不过，即使是在这样一个简单的计算机中，您也会有问题，尤其是当您不知道程序的每个部分将需要多少内存时。如果您的空间有限，而内存需求是变化的，那么您需要一些方法来满足这些需求： 确定您是否有足够的内存来处理数据。 从可用的内存中获取一部分内存。 向可用内存池（pool）中返回部分内存，以使其可以由程序的其他部分或者其他程序使用。 实现这些需求的程序库称为 分配程序（allocators），因为它们负责分配和回收内存。程序的动态性越强，内存管理就越重要，您的内存分配程序的选择也就更重要。让我们来了解可用于内存管理的不同方法，它们的好处与不足，以及它们最适用的情形。 回页首 C 风格的内存分配程序 C 编程语言提供了两个函数来满足我们的三个需求： malloc：该函数分配给定的字节数，并返回一个指向它们的指针。如果没有足够的可用内存，那么它返回一个空指针。 free：该函数获得指向由 malloc 分配的内存片段的指针，并将其释放，以便以后的程序或操作系统使用（实际上，一些 malloc 实现只能将内存归还给程序，而无法将内存归还给操作系统）。 物理内存和虚拟内存 要理解内存在程序中是如何分配的，首先需要理解如何将内存从操作系统分配给程序。计算机上的每一个进程都认为自己可以访问所有的物理内存。显然，由于同时在运行多个程序，所以每个进程不可能拥有全部内存。实际上，这些进程使用的是 虚拟内存。 只是作为一个例子，让我们假定您的程序正在访问地址为 629 的内存。不过，虚拟内存系统不需要将其存储在位置为 629 的 RAM 中。实际上，它甚至可以不在 RAM 中 —— 如果物理 RAM 已经满了，它甚至可能已经被转移到硬盘上！由于这类地址不必反映内存所在的物理位置，所以它们被称为虚拟内存。操作系统维持着一个虚拟地址到物理地址的转换的表，以便计算机硬件可以正确地响应地址请求。并且，如果地址在硬盘上而不是在 RAM 中，那么操作系统将暂时停止您的进程，将其他内存转存到硬盘中，从硬盘上加载被请求的内存，然后再重新启动您的进程。这样，每个进程都获得了自己可以使用的地址空间，可以访问比您物理上安装的内存更多的内存。 在 32-位 x86 系统上，每一个进程可以访问 4 GB 内存。现在，大部分人的系统上并没有 4 GB 内存，即使您将 swap 也算上， 每个进程所使用的内存也肯定少于 4 GB。因此，当加载一个进程时，它会得到一个取决于某个称为 系统中断点（system break）的特定地址的初始内存分配。该地址之后是未被映射的内存 —— 用于在 RAM 或者硬盘中没有分配相应物理位置的内存。因此，如果一个进程运行超出了它初始分配的内存，那么它必须请求操作系统“映射进来（map in）”更多的内存。（映射是一个表示一一对应关系的数学术语 —— 当内存的虚拟地址有一个对应的物理地址来存储内存内容时，该内存将被映射。） 基于 UNIX 的系统有两个可映射到附加内存中的基本系统调用： brk： brk() 是一个非常简单的系统调用。还记得系统中断点吗？该位置是进程映射的内存边界。 brk() 只是简单地将这个位置向前或者向后移动，就可以向进程添加内存或者从进程取走内存。 mmap： mmap()，或者说是“内存映像”，类似于 brk()，但是更为灵活。首先，它可以映射任何位置的内存，而不单单只局限于进程。其次，它不仅可以将虚拟地址映射到物理的 RAM 或者 swap，它还可以将它们映射到文件和文件位置，这样，读写内存将对文件中的数据进行读写。不过，在这里，我们只关心 mmap 向进程添加被映射的内存的能力。 munmap() 所做的事情与 mmap() 相反。 如您所见， brk() 或者 mmap() 都可以用来向我们的进程添加额外的虚拟内存。在我们的例子中将使用 brk()，因为它更简单，更通用。 实现一个简单的分配程序 如果您曾经编写过很多 C 程序，那么您可能曾多次使用过 malloc() 和 free()。不过，您可能没有用一些时间去思考它们在您的操作系统中是如何实现的。本节将向您展示 malloc 和 free 的一个最简化实现的代码，来帮助说明管理内存时都涉及到了哪些事情。 要试着运行这些示例，需要先 复制本代码清单，并将其粘贴到一个名为 malloc.c 的文件中。接下来，我将一次一个部分地对该清单进行解释。 在大部分操作系统中，内存分配由以下两个简单的函数来处理： void *malloc(long numbytes)：该函数负责分配 numbytes 大小的内存，并返回指向第一个字节的指针。 void free(void *firstbyte)：如果给定一个由先前的 malloc 返回的指针，那么该函数会将分配的空间归还给进程的“空闲空间”。 malloc_init 将是初始化内存分配程序的函数。它要完成以下三件事：将分配程序标识为已经初始化，找到系统中最后一个有效内存地址，然后建立起指向我们管理的内存的指针。这三个变量都是全局变量： 清单 1. 我们的简单分配程序的全局变量 int has_initialized = 0; void *managed_memory_start; void *last_valid_address; 如前所述，被映射的内存的边界（最后一个有效地址）常被称为系统中断点或者 当前中断点。在很多 UNIX® 系统中，为了指出当前系统中断点，必须使用 sbrk(0) 函数。 sbrk 根据参数中给出的字节数移动当前系统中断点，然后返回新的系统中断点。使用参数 0 只是返回当前中断点。这里是我们的 malloc 初始化代码，它将找到当前中断点并初始化我们的变量： 清单 2. 分配程序初始化函数 /* Include the sbrk function */ #include void malloc_init() { /* grab the last valid address from the OS */ last_valid_address = sbrk(0); /* we don't have any memory to manage yet, so *just set the beginning to be last_valid_address */ managed_memory_start = last_valid_address; /* Okay, we're initialized and ready to go */ has_initialized = 1; } 现在，为了完全地管理内存，我们需要能够追踪要分配和回收哪些内存。在对内存块进行了 free 调用之后，我们需要做的是诸如将它们标记为未被使用的等事情，并且，在调用 malloc 时，我们要能够定位未被使用的内存块。因此， malloc 返回的每块内存的起始处首先要有这个结构： 清单 3. 内存控制块结构定义 struct mem_control_block { int is_available; int size; }; 现在，您可能会认为当程序调用 malloc 时这会引发问题 —— 它们如何知道这个结构？答案是它们不必知道；在返回指针之前，我们会将其移动到这个结构之后，把它隐藏起来。这使得返回的指针指向没有用于任何其他用途的内存。那样，从调用程序的角度来看，它们所得到的全部是空闲的、开放的内存。然后，当通过 free() 将该指针传递回来时，我们只需要倒退几个内存字节就可以再次找到这个结构。 在讨论分配内存之前，我们将先讨论释放，因为它更简单。为了释放内存，我们必须要做的惟一一件事情就是，获得我们给出的指针，回退 sizeof(struct mem_control_block) 个字节，并将其标记为可用的。这里是对应的代码： 清单 4. 解除分配函数 void free(void *firstbyte) { struct mem_control_block *mcb; /* Backup from the given pointer to find the * mem_control_block */ mcb = firstbyte - sizeof(struct mem_control_block); /* Mark the block as being available */ mcb->is_available = 1; /* That's It! We're done. */ return; } 如您所见，在这个分配程序中，内存的释放使用了一个非常简单的机制，在固定时间内完成内存释放。分配内存稍微困难一些。以下是该算法的略述： 清单 5. 主分配程序的伪代码 1. If our allocator has not been initialized, initialize it. 2. Add sizeof(struct mem_control_block) to the size requested. 3. start at managed_memory_start. 4. Are we at last_valid address? 5. If we are: A. We didn't find any existing space that was large enough -- ask the operating system for more and return that. 6. Otherwise: A. Is the current space available (check is_available from the mem_control_block)? B. If it is: i) Is it large enough (check "size" from the mem_control_block)? ii) If so: a. Mark it as unavailable b. Move past mem_control_block and return the pointer iii) Otherwise: a. Move forward "size" bytes b. Go back go step 4 C. Otherwise: i) Move forward "size" bytes ii) Go back to step 4 我们主要使用连接的指针遍历内存来寻找开放的内存块。这里是代码： 清单 6. 主分配程序 void *malloc(long numbytes) { /* Holds where we are looking in memory */ void *current_location; /* This is the same as current_location, but cast to a * memory_control_block */ struct mem_control_block *current_location_mcb; /* This is the memory location we will return. It will * be set to 0 until we find something suitable */ void *memory_location; /* Initialize if we haven't already done so */ if(! has_initialized) { malloc_init(); } /* The memory we search for has to include the memory * control block, but the users of malloc don't need * to know this, so we'll just add it in for them. */ numbytes = numbytes + sizeof(struct mem_control_block); /* Set memory_location to 0 until we find a suitable * location */ memory_location = 0; /* Begin searching at the start of managed memory */ current_location = managed_memory_start; /* Keep going until we have searched all allocated space */ while(current_location != last_valid_address) { /* current_location and current_location_mcb point * to the same address. However, current_location_mcb * is of the correct type, so we can use it as a struct. * current_location is a void pointer so we can use it * to calculate addresses. */ current_location_mcb = (struct mem_control_block *)current_location; if(current_location_mcb->is_available) { if(current_location_mcb->size >= numbytes) { /* Woohoo! We've found an open, * appropriately-size location. */ /* It is no longer available */ current_location_mcb->is_available = 0; /* We own it */ memory_location = current_location; /* Leave the loop */ break; } } /* If we made it here, it's because the Current memory * block not suitable; move to the next one */ current_location = current_location + current_location_mcb->size; } /* If we still don't have a valid location, we'll * have to ask the operating system for more memory */ if(! memory_location) { /* Move the program break numbytes further */ sbrk(numbytes); /* The new memory will be where the last valid * address left off */ memory_location = last_valid_address; /* We'll move the last valid address forward * numbytes */ last_valid_address = last_valid_address + numbytes; /* We need to initialize the mem_control_block */ current_location_mcb = memory_location; current_location_mcb->is_available = 0; current_location_mcb->size = numbytes; } /* Now, no matter what (well, except for error conditions), * memory_location has the address of the memory, including * the mem_control_block */ /* Move the pointer past the mem_control_block */ memory_location = memory_location + sizeof(struct mem_control_block); /* Return the pointer */ return memory_location; } 这就是我们的内存管理器。现在，我们只需要构建它，并在程序中使用它即可。 运行下面的命令来构建 malloc 兼容的分配程序（实际上，我们忽略了 realloc() 等一些函数，不过， malloc() 和 free() 才是最主要的函数）： 清单 7. 编译分配程序 gcc -shared -fpic malloc.c -o malloc.so 该程序将生成一个名为 malloc.so 的文件，它是一个包含有我们的代码的共享库。 在 UNIX 系统中，现在您可以用您的分配程序来取代系统的 malloc()，做法如下： 清单 8. 替换您的标准的 malloc LD_PRELOAD=/path/to/malloc.so export LD_PRELOAD LD_PRELOAD 环境变量使动态链接器在加载任何可执行程序之前，先加载给定的共享库的符号。它还为特定库中的符号赋予优先权。因此，从现在起，该会话中的任何应用程序都将使用我们的 malloc()，而不是只有系统的应用程序能够使用。有一些应用程序不使用 malloc()，不过它们是例外。其他使用 realloc() 等其他内存管理函数的应用程序，或者错误地假定 malloc() 内部行为的那些应用程序，很可能会崩溃。ash shell 似乎可以使用我们的新 malloc() 很好地工作。 如果您想确保 malloc() 正在被使用，那么您应该通过向函数的入口点添加 write() 调用来进行测试。 我们的内存管理器在很多方面都还存在欠缺，但它可以有效地展示内存管理需要做什么事情。它的某些缺点包括： 由于它对系统中断点（一个全局变量）进行操作，所以它不能与其他分配程序或者 mmap 一起使用。 当分配内存时，在最坏的情形下，它将不得不遍历 全部进程内存；其中可能包括位于硬盘上的很多内存，这意味着操作系统将不得不花时间去向硬盘移入数据和从硬盘中移出数据。 没有很好的内存不足处理方案（ malloc 只假定内存分配是成功的）。 它没有实现很多其他的内存函数，比如 realloc()。 由于 sbrk() 可能会交回比我们请求的更多的内存，所以在堆（heap）的末端会遗漏一些内存。 虽然 is_available 标记只包含一位信息，但它要使用完整的 4-字节 的字。 分配程序不是线程安全的。 分配程序不能将空闲空间拼合为更大的内存块。 分配程序的过于简单的匹配算法会导致产生很多潜在的内存碎片。 我确信还有很多其他问题。这就是为什么它只是一个例子! 其他 malloc 实现 malloc() 的实现有很多，这些实现各有优点与缺点。在设计一个分配程序时，要面临许多需要折衷的选择，其中包括： 分配的速度。 回收的速度。 有线程的环境的行为。 内存将要被用光时的行为。 局部缓存。 簿记（Bookkeeping）内存开销。 虚拟内存环境中的行为。 小的或者大的对象。 实时保证。 每一个实现都有其自身的优缺点集合。在我们的简单的分配程序中，分配非常慢，而回收非常快。另外，由于它在使用虚拟内存系统方面较差，所以它最适于处理大的对象。 还有其他许多分配程序可以使用。其中包括： Doug Lea Malloc：Doug Lea Malloc 实际上是完整的一组分配程序，其中包括 Doug Lea 的原始分配程序，GNU libc 分配程序和 ptmalloc。 Doug Lea 的分配程序有着与我们的版本非常类似的基本结构，但是它加入了索引，这使得搜索速度更快，并且可以将多个没有被使用的块组合为一个大的块。它还支持缓存，以便更快地再次使用最近释放的内存。 ptmalloc 是 Doug Lea Malloc 的一个扩展版本，支持多线程。在本文后面的 参考资料部分中，有一篇描述 Doug Lea 的 Malloc 实现的文章。 BSD Malloc：BSD Malloc 是随 4.2 BSD 发行的实现，包含在 FreeBSD 之中，这个分配程序可以从预先确实大小的对象构成的池中分配对象。它有一些用于对象大小的 size 类，这些对象的大小为 2 的若干次幂减去某一常数。所以，如果您请求给定大小的一个对象，它就简单地分配一个与之匹配的 size 类。这样就提供了一个快速的实现，但是可能会浪费内存。在 参考资料部分中，有一篇描述该实现的文章。 Hoard：编写 Hoard 的目标是使内存分配在多线程环境中进行得非常快。因此，它的构造以锁的使用为中心，从而使所有进程不必等待分配内存。它可以显著地加快那些进行很多分配和回收的多线程进程的速度。在 参考资料部分中，有一篇描述该实现的文章。 众多可用的分配程序中最有名的就是上述这些分配程序。如果您的程序有特别的分配需求，那么您可能更愿意编写一个定制的能匹配您的程序内存分配方式的分配程序。不过，如果不熟悉分配程序的设计，那么定制分配程序通常会带来比它们解决的问题更多的问题。要获得关于该主题的适当的介绍，请参阅 Donald Knuth 撰写的 The Art of Computer Programming Volume 1: Fundamental Algorithms 中的第 2.5 节“Dynamic Storage Allocation”（请参阅 参考资料中的链接）。它有点过时，因为它没有考虑虚拟内存环境，不过大部分算法都是基于前面给出的函数。 在 C++ 中，通过重载 operator new()，您可以以每个类或者每个模板为单位实现自己的分配程序。在 Andrei Alexandrescu 撰写的 Modern C++ Design 的第 4 章（“Small Object Allocation”）中，描述了一个小对象分配程序（请参阅 参考资料中的链接）。 基于 malloc() 的内存管理的缺点 不只是我们的内存管理器有缺点，基于 malloc() 的内存管理器仍然也有很多缺点，不管您使用的是哪个分配程序。对于那些需要保持长期存储的程序使用 malloc() 来管理内存可能会非常令人失望。如果您有大量的不固定的内存引用，经常难以知道它们何时被释放。生存期局限于当前函数的内存非常容易管理，但是对于生存期超出该范围的内存来说，管理内存则困难得多。而且，关于内存管理是由进行调用的程序还是由被调用的函数来负责这一问题，很多 API 都不是很明确。 因为管理内存的问题，很多程序倾向于使用它们自己的内存管理规则。C++ 的异常处理使得这项任务更成问题。有时好像致力于管理内存分配和清理的代码比实际完成计算任务的代码还要多！因此，我们将研究内存管理的其他选择。 回页首 半自动内存管理策略 引用计数 引用计数是一种 半自动（semi-automated）的内存管理技术，这表示它需要一些编程支持，但是它不需要您确切知道某一对象何时不再被使用。引用计数机制为您完成内存管理任务。 在引用计数中，所有共享的数据结构都有一个域来包含当前活动“引用”结构的次数。当向一个程序传递一个指向某个数据结构指针时，该程序会将引用计数增加 1。实质上，您是在告诉数据结构，它正在被存储在多少个位置上。然后，当您的进程完成对它的使用后，该程序就会将引用计数减少 1。结束这个动作之后，它还会检查计数是否已经减到零。如果是，那么它将释放内存。 这样做的好处是，您不必追踪程序中某个给定的数据结构可能会遵循的每一条路径。每次对其局部的引用，都将导致计数的适当增加或减少。这样可以防止在使用数据结构时释放该结构。不过，当您使用某个采用引用计数的数据结构时，您必须记得运行引用计数函数。另外，内置函数和第三方的库不会知道或者可以使用您的引用计数机制。引用计数也难以处理发生循环引用的数据结构。 要实现引用计数，您只需要两个函数 —— 一个增加引用计数，一个减少引用计数并当计数减少到零时释放内存。 一个示例引用计数函数集可能看起来如下所示： 清单 9. 基本的引用计数函数 /* Structure Definitions*/ /* Base structure that holds a refcount */ struct refcountedstruct { int refcount; } /* All refcounted structures must mirror struct * refcountedstruct for their first variables */ /* Refcount maintenance functions */ /* Increase reference count */ void REF(void *data) { struct refcountedstruct *rstruct; rstruct = (struct refcountedstruct *) data; rstruct->refcount++; } /* Decrease reference count */ void UNREF(void *data) { struct refcountedstruct *rstruct; rstruct = (struct refcountedstruct *) data; rstruct->refcount--; /* Free the structure if there are no more users */ if(rstruct->refcount == 0) { free(rstruct); } } REF 和 UNREF 可能会更复杂，这取决于您想要做的事情。例如，您可能想要为多线程程序增加锁，那么您可能想扩展 refcountedstruct，使它同样包含一个指向某个在释放内存之前要调用的函数的指针（类似于面向对象语言中的析构函数 —— 如果您的结构中包含这些指针，那么这是 必需的）。 当使用 REF 和 UNREF 时，您需要遵守这些指针的分配规则： UNREF 分配前左端指针（left-hand-side pointer）指向的值。 REF 分配后左端指针（left-hand-side pointer）指向的值。 在传递使用引用计数的结构的函数中，函数需要遵循以下这些规则： 在函数的起始处 REF 每一个指针。 在函数的结束处 UNREF 第一个指针。 以下是一个使用引用计数的生动的代码示例： 清单 10. 使用引用计数的示例 /* EXAMPLES OF USAGE */ /* Data type to be refcounted */ struct mydata { int refcount; /* same as refcountedstruct */ int datafield1; /* Fields specific to this struct */ int datafield2; /* other declarations would go here as appropriate */ }; /* Use the functions in code */ void dosomething(struct mydata *data) { REF(data); /* Process data */ /* when we are through */ UNREF(data); } struct mydata *globalvar1; /* Note that in this one, we don't decrease the * refcount since we are maintaining the reference * past the end of the function call through the * global variable */ void storesomething(struct mydata *data) { REF(data); /* passed as a parameter */ globalvar1 = data; REF(data); /* ref because of Assignment */ UNREF(data); /* Function finished */ } 由于引用计数是如此简单，大部分程序员都自已去实现它，而不是使用库。不过，它们依赖于 malloc 和 free 等低层的分配程序来实际地分配和释放它们的内存。 在 Perl 等高级语言中，进行内存管理时使用引用计数非常广泛。在这些语言中，引用计数由语言自动地处理，所以您根本不必担心它，除非要编写扩展模块。由于所有内容都必须进行引用计数，所以这会对速度产生一些影响，但它极大地提高了编程的安全性和方便性。以下是引用计数的益处： 实现简单。 易于使用。 由于引用是数据结构的一部分，所以它有一个好的缓存位置。 不过，它也有其不足之处： 要求您永远不要忘记调用引用计数函数。 无法释放作为循环数据结构的一部分的结构。 减缓几乎每一个指针的分配。 尽管所使用的对象采用了引用计数，但是当使用异常处理（比如 try 或 setjmp()/ longjmp()）时，您必须采取其他方法。 需要额外的内存来处理引用。 引用计数占用了结构中的第一个位置，在大部分机器中最快可以访问到的就是这个位置。 在多线程环境中更慢也更难以使用。 C++ 可以通过使用 智能指针（smart pointers）来容忍程序员所犯的一些错误，智能指针可以为您处理引用计数等指针处理细节。不过，如果不得不使用任何先前的不能处理智能指针的代码（比如对 C 库的联接），实际上，使用它们的后果通实比不使用它们更为困难和复杂。因此，它通常只是有益于纯 C++ 项目。如果您想使用智能指针，那么您实在应该去阅读 Alexandrescu 撰写的 Modern C++ Design 一书中的“Smart Pointers”那一章。 内存池 内存池是另一种半自动内存管理方法。内存池帮助某些程序进行自动内存管理，这些程序会经历一些特定的阶段，而且每个阶段中都有分配给进程的特定阶段的内存。例如，很多网络服务器进程都会分配很多针对每个连接的内存 —— 内存的最大生存期限为当前连接的存在期。Apache 使用了池式内存（pooled memory），将其连接拆分为各个阶段，每个阶段都有自己的内存池。在结束每个阶段时，会一次释放所有内存。 在池式内存管理中，每次内存分配都会指定内存池，从中分配内存。每个内存池都有不同的生存期限。在 Apache 中，有一个持续时间为服务器存在期的内存池，还有一个持续时间为连接的存在期的内存池，以及一个持续时间为请求的存在期的池，另外还有其他一些内存池。因此，如果我的一系列函数不会生成比连接持续时间更长的数据，那么我就可以完全从连接池中分配内存，并知道在连接结束时，这些内存会被自动释放。另外，有一些实现允许注册 清除函数（cleanup functions），在清除内存池之前，恰好可以调用它，来完成在内存被清理前需要完成的其他所有任务（类似于面向对象中的析构函数）。 要在自己的程序中使用池，您既可以使用 GNU libc 的 obstack 实现，也可以使用 Apache 的 Apache Portable Runtime。GNU obstack 的好处在于，基于 GNU 的 Linux 发行版本中默认会包括它们。Apache Portable Runtime 的好处在于它有很多其他工具，可以处理编写多平台服务器软件所有方面的事情。要深入了解 GNU obstack 和 Apache 的池式内存实现，请参阅 参考资料部分中指向这些实现的文档的链接。 下面的假想代码列表展示了如何使用 obstack： 清单 11. obstack 的示例代码 #include #include /* Example code listing for using obstacks */ /* Used for obstack macros (xmalloc is a malloc function that exits if memory is exhausted */ #define obstack_chunk_alloc xmalloc #define obstack_chunk_free free /* Pools */ /* Only permanent allocations should go in this pool */ struct obstack *global_pool; /* This pool is for per-connection data */ struct obstack *connection_pool; /* This pool is for per-request data */ struct obstack *request_pool; void allocation_failed() { exit(1); } int main() { /* Initialize Pools */ global_pool = (struct obstack *) xmalloc (sizeof (struct obstack)); obstack_init(global_pool); connection_pool = (struct obstack *) xmalloc (sizeof (struct obstack)); obstack_init(connection_pool); request_pool = (struct obstack *) xmalloc (sizeof (struct obstack)); obstack_init(request_pool); /* Set the error handling function */ obstack_alloc_failed_handler = &allocation_failed; /* Server main loop */ while(1) { wait_for_connection(); /* We are in a connection */ while(more_requests_available()) { /* Handle request */ handle_request(); /* Free all of the memory allocated * in the request pool */ obstack_free(request_pool, NULL); } /* We're finished with the connection, time * to free that pool */ obstack_free(connection_pool, NULL); } } int handle_request() { /* Be sure that all object allocations are allocated * from the request pool */ int bytes_i_need = 400; void *data1 = obstack_alloc(request_pool, bytes_i_need); /* Do stuff to process the request */ /* return */ return 0; } 基本上，在操作的每一个主要阶段结束之后，这个阶段的 obstack 会被释放。不过，要注意的是，如果一个过程需要分配持续时间比当前阶段更长的内存，那么它也可以使用更长期限的 obstack，比如连接或者全局内存。传递给 obstack_free() 的 NULL 指出它应该释放 obstack 的全部内容。可以用其他的值，但是它们通常不怎么实用。 使用池式内存分配的益处如下所示： 应用程序可以简单地管理内存。 内存分配和回收更快，因为每次都是在一个池中完成的。分配可以在 O(1) 时间内完成，释放内存池所需时间也差不多（实际上是 O(n) 时间，不过在大部分情况下会除以一个大的因数，使其变成 O(1)）。 可以预先分配错误处理池（Error-handling pools），以便程序在常规内存被耗尽时仍可以恢复。 有非常易于使用的标准实现。 池式内存的缺点是： 内存池只适用于操作可以分阶段的程序。 内存池通常不能与第三方库很好地合作。 如果程序的结构发生变化，则不得不修改内存池，这可能会导致内存管理系统的重新设计。 您必须记住需要从哪个池进行分配。另外，如果在这里出错，就很难捕获该内存池。 回页首 垃圾收集 垃圾收集（Garbage collection）是全自动地检测并移除不再使用的数据对象。垃圾收集器通常会在当可用内存减少到少于一个具体的阈值时运行。通常，它们以程序所知的可用的一组“基本”数据 —— 栈数据、全局变量、寄存器 —— 作为出发点。然后它们尝试去追踪通过这些数据连接到每一块数据。收集器找到的都是有用的数据；它没有找到的就是垃圾，可以被销毁并重新使用这些无用的数据。为了有效地管理内存，很多类型的垃圾收集器都需要知道数据结构内部指针的规划，所以，为了正确运行垃圾收集器，它们必须是语言本身的一部分。 收集器的类型 复制（copying）： 这些收集器将内存存储器分为两部分，只允许数据驻留在其中一部分上。它们定时地从“基本”的元素开始将数据从一部分复制到另一部分。内存新近被占用的部分现在成为活动的，另一部分上的所有内容都认为是垃圾。另外，当进行这项复制操作时，所有指针都必须被更新为指向每个内存条目的新位置。因此，为使用这种垃圾收集方法，垃圾收集器必须与编程语言集成在一起。 标记并清理（Mark and sweep）：每一块数据都被加上一个标签。不定期的，所有标签都被设置为 0，收集器从“基本”的元素开始遍历数据。当它遇到内存时，就将标签标记为 1。最后没有被标记为 1 的所有内容都认为是垃圾，以后分配内存时会重新使用它们。 增量的（Incremental）：增量垃圾收集器不需要遍历全部数据对象。因为在收集期间的突然等待，也因为与访问所有当前数据相关的缓存问题（所有内容都不得不被页入（page-in）），遍历所有内存会引发问题。增量收集器避免了这些问题。 保守的（Conservative）：保守的垃圾收集器在管理内存时不需要知道与数据结构相关的任何信息。它们只查看所有数据类型，并假定它们 可以全部都是指针。所以，如果一个字节序列可以是一个指向一块被分配的内存的指针，那么收集器就将其标记为正在被引用。有时没有被引用的内存会被收集，这样会引发问题，例如，如果一个整数域中包含一个值，该值是已分配内存的地址。不过，这种情况极少发生，而且它只会浪费少量内存。保守的收集器的优势是，它们可以与任何编程语言相集成。 Hans Boehm 的保守垃圾收集器是可用的最流行的垃圾收集器之一，因为它是免费的，而且既是保守的又是增量的，可以使用 --enable-redirect-malloc 选项来构建它，并且可以将它用作系统分配程序的简易替代者（drop-in replacement）（用 malloc/ free 代替它自己的 API）。实际上，如果这样做，您就可以使用与我们在示例分配程序中所使用的相同的 LD_PRELOAD 技巧，在系统上的几乎任何程序中启用垃圾收集。如果您怀疑某个程序正在泄漏内存，那么您可以使用这个垃圾收集器来控制进程。在早期，当 Mozilla 严重地泄漏内存时，很多人在其中使用了这项技术。这种垃圾收集器既可以在 Windows® 下运行，也可以在 UNIX 下运行。 垃圾收集的一些优点： 您永远不必担心内存的双重释放或者对象的生命周期。 使用某些收集器，您可以使用与常规分配相同的 API。 其缺点包括： 使用大部分收集器时，您都无法干涉何时释放内存。 在多数情况下，垃圾收集比其他形式的内存管理更慢。 垃圾收集错误引发的缺陷难于调试。 如果您忘记将不再使用的指针设置为 null，那么仍然会有内存泄漏。 回页首 结束语 一切都需要折衷：性能、易用、易于实现、支持线程的能力等，这里只列出了其中的一些。为了满足项目的要求，有很多内存管理模式可以供您使用。每种模式都有大量的实现，各有其优缺点。对很多项目来说，使用编程环境默认的技术就足够了，不过，当您的项目有特殊的需要时，了解可用的选择将会有帮助。下表对比了本文中涉及的内存管理策略。 表 1. 内存分配策略的对比 策略 分配速度 回收速度 局部缓存 易用性 通用性 实时可用 SMP 线程友好 定制分配程序 取决于实现 取决于实现 取决于实现 很难 无 取决于实现 取决于实现 简单分配程序 内存使用少时较快 很快 差 容易 高 否 否 GNU malloc 中 快 中 容易 高 否 中 Hoard 中 中 中 容易 高 否 是 引用计数 N/A N/A 非常好 中 中 是（取决于 malloc 实现） 取决于实现 池 中 非常快 极好 中 中 是（取决于 malloc 实现） 取决于实现 垃圾收集 中（进行收集时慢） 中 差 中 中 否 几乎不 增量垃圾收集 中 中 中 中 中 否 几乎不 增量保守垃圾收集 中 中 中 容易 高 否 几乎不 参考资料 您可以参阅本文在 developerWorks 全球站点上的 英文原文。 Web 上的文档 GNU C Library 手册的 obstacks 部分 提供了 obstacks 编程接口。 Apache Portable Runtime 文档 描述了它们的池式分配程序的接口。 基本的分配程序 Doug Lea 的 Malloc 是最流行的内存分配程序之一。 BSD Malloc 用于大部分基于 BSD 的系统中。 ptmalloc 起源于 Doug Lea 的 malloc，用于 GLIBC 之中。 Hoard 是一个为多线程应用程序优化的 malloc 实现。 GNU Memory-Mapped Malloc（GDB 的组成部分） 是一个基于 mmap() 的 malloc 实现。 池式分配程序 GNU Obstacks（GNU Libc 的组成部分）是安装最多的池式分配程序，因为在每一个基于 glibc 的系统中都有它。 Apache 的池式分配程序（Apache Portable Runtime 中） 是应用最为广泛的池式分配程序。 Squid 有其自己的池式分配程序。 NetBSD 也有其自己的池式分配程序。 talloc 是一个池式分配程序，是 Samba 的组成部分。 智能指针和定制分配程序 Loki C++ Library 有很多为 C++ 实现的通用模式，包括智能指针和一个定制的小对象分配程序。 垃圾收集器 Hahns Boehm Conservative Garbage Collector 是最流行的开源垃圾收集器，它可以用于常规的 C/C++ 程序。 关于现代操作系统中的虚拟内存的文章 Marshall Kirk McKusick 和 Michael J. Karels 合著的 A New Virtual Memory Implementation for Berkeley UNIX 讨论了 BSD 的 VM 系统。 Mel Gorman's Linux VM Documentation 讨论了 Linux VM 系统。 关于 malloc 的文章 Poul-Henning Kamp 撰写的 Malloc in Modern Virtual Memory Environments 讨论的是 malloc 以及它如何与 BSD 虚拟内存交互。 Berger、McKinley、Blumofe 和 Wilson 合著的 Hoard -- a Scalable Memory Allocator for Multithreaded Environments 讨论了 Hoard 分配程序的实现。 Marshall Kirk McKusick 和 Michael J. Karels 合著的 Design of a General Purpose Memory Allocator for the 4.3BSD UNIX Kernel 讨论了内核级的分配程序。 Doug Lea 撰写的 A Memory Allocator 给出了一个关于设计和实现分配程序的概述，其中包括设计选择与折衷。 Emery D. Berger 撰写的 Memory Management for High-Performance Applications 讨论的是定制内存管理以及它如何影响高性能应用程序。 关于定制分配程序的文章 Doug Lea 撰写的 Some Storage Management Techniques for Container Classes 描述的是为 C++ 类编写定制分配程序。 Berger、Zorn 和 McKinley 合著的 Composing High-Performance Memory Allocators 讨论了如何编写定制分配程序来加快具体工作的速度。 Berger、Zorn 和 McKinley 合著的 Reconsidering Custom Memory Allocation 再次提及了定制分配的主题，看是否真正值得为其费心。 关于垃圾收集的文章 Paul R. Wilson 撰写的 Uniprocessor Garbage Collection Techniques 给出了垃圾收集的一个基本概述。 Benjamin Zorn 撰写的 The Measured Cost of Garbage Collection 给出了关于垃圾收集和性能的硬数据（hard data）。 Hans-Juergen Boehm 撰写的 Memory Allocation Myths and Half-Truths 给出了关于垃圾收集的神话（myths）。 Hans-Juergen Boehm 撰写的 Space Efficient Conservative Garbage Collection 是一篇描述他的用于 C/C++ 的垃圾收集器的文章。 Web 上的通用参考资料 内存管理参考 中有很多关于内存管理参考资料和技术文章的链接。 关于内存管理和内存层级的 OOPS Group Papers 是非常好的一组关于此主题的技术文章。 C++ 中的内存管理讨论的是为 C++ 编写定制的分配程序。 Programming Alternatives: Memory Management 讨论了程序员进行内存管理时的一些选择。 垃圾收集 FAQ 讨论了关于垃圾收集您需要了解的所有内容。 Richard Jones 的 Garbage Collection Bibliography 有指向任何您想要的关于垃圾收集的文章的链接。 书籍 Michael Daconta 撰写的 C++ Pointers and Dynamic Memory Management 介绍了关于内存管理的很多技术。 Frantisek Franek 撰写的 Memory as a Programming Concept in C and C++ 讨论了有效使用内存的技术与工具，并给出了在计算机编程中应当引起注意的内存相关错误的角色。 Richard Jones 和 Rafael Lins 合著的 Garbage Collection: Algorithms for Automatic Dynamic Memory Management 描述了当前使用的最常见的垃圾收集算法。 在 Donald Knuth 撰写的 The Art of Computer Programming 第 1 卷 Fundamental Algorithms 的第 2.5 节“Dynamic Storage Allocation”中，描述了实现基本的分配程序的一些技术。 在 Donald Knuth 撰写的 The Art of Computer Programming 第 1 卷 Fundamental Algorithms 的第 2.3.5 节“Lists and Garbage Collection”中，讨论了用于列表的垃圾收集算法。 Andrei Alexandrescu 撰写的 Modern C++ Design 第 4 章“Small Object Allocation”描述了一个比 C++ 标准分配程序效率高得多的一个高速小对象分配程序。 Andrei Alexandrescu 撰写的 Modern C++ Design 第 7 章“Smart Pointers”描述了在 C++ 中智能指针的实现。 Jonathan 撰写的 Programming from the Ground Up 第 8 章“Intermediate Memory Topics”中有本文使用的简单分配程序的一个汇编语言版本。 来自 developerWorks 自我管理数据缓冲区内存 （developerWorks，2004 年 1 月）略述了一个用于管理内存的自管理的抽象数据缓存器的伪 C （pseudo-C）实现。 A framework for the user defined malloc replacement feature （developerWorks，2002 年 2 月）展示了如何利用 AIX 中的一个工具，使用自己设计的内存子系统取代原有的内存子系统。 掌握 Linux 调试技术 （developerWorks，2002 年 8 月）描述了可以使用调试方法的 4 种不同情形：段错误、内存溢出、内存泄漏和挂起。 在 处理 Java 程序中的内存漏洞 （developerWorks，2001 年 2 月）中，了解导致 Java 内存泄漏的原因，以及何时需要考虑它们。 在 developerWorks Linux 专区中，可以找到更多为 Linux 开发人员准备的参考资料。 从 developerWorks 的 Speed-start your Linux app 专区中，可以下载运行于 Linux 之上的 IBM 中间件产品的免费测试版本，其中包括 WebSphere® Studio Application Developer、WebSphere Application Server、DB2® Universal Database、Tivoli® Access Manager 和 Tivoli Directory Server，查找 how-to 文章和技术支持。 通过参与 developerWorks blogs 加入到 developerWorks 社区。 可以在 Developer Bookstore Linux 专栏中定购 打折出售的 Linux 书籍。 关于作者 Jonathan Bartlett 是 Programming from the Ground Up 一书的作者，这本书介绍的是 Linux 汇编语言编程。Jonathan Bartlett 是 New Media Worx 的总开发师，负责为客户开发 Web、视频、kiosk 和桌面应用程序。您可以通过 [email protected] 与 Jonathan 联系。
SQL Server 2008商业智能完美解决方案 1/3
03-03
完整清晰 PDF 扫描文档 这个PDF文件是我花钱买来的，现在为了挣积分，拿出来与大家分享！！ SQL Server 2008商业智能完美解决方案 1/3 SQL Server 2008 2010 商业智能完美解决方案 作者:兰吉特(Lynn Langit) 出版社：人民邮电出版社; 第1版 (2010年8月1日) ISBN：7115231117, 9787115231116 页码：545 -------------------------------------------------------------------------------- 《SQL Server 2008商业智能完美解决方案》： 利用Microsoft SQL Server 2008实现灵活的商业智能解决方案使用Microsoft 完善的BI工具构建B0解决方案的必备指南，使用SQLServer 2008设计、开发和部署更有效的数据集成、报表、分析解决方案所需的权威操作指南。不论是商业智能(B0)编程的新手还是老手，都会从中受益。通过专家团队的真实示例和高明见解，读者能够掌握构建商业智能解决方案的概念、工具和技术，从而真正提供客户所需的智能性商业价值。 《SQL Server 2008商业智能完美解决方案》研究如下内容： 管理开发生命周期，打造BI团队； 深入研究SQL Servet Analysis Services、Integration Services和 Reporting Services； 使用Business Intelligence Development Studio(BIDS)； 编写对销售数据进行分级、排序和深化的查询； 开发提取、转换、加载(ETL)解决方案； 添加源代码控制系统； 通过加密和凭据保护部署的包； 用MDX和DMX查询设计器构建基于OLAP多维数据集和数据挖掘模 型的报表； 用NET代码建立并实现自定义对象； 在Microsoft Office Excel和Office SharePoint Server中查看报表。 微软公司US-SQL Analysis Services 首席开发经理Donaod Farmer倾力作序 内容提要 -------------------------------------------------------------------------------- 《SQL Server 2008商业智能完美解决方案》介绍如何使用Microsoft SQL Server 2008开发商业智能(BI)解决方案。《SQL Server 2008商业智能完美解决方案》共分为4部分。第一部分阐述了商业智能基础、可视化商业智能结果、构建有效的商业智能流程、商业智能解决方案的物理架构、面向架构师的OLAP逻辑设计概念；第二部分面向Analysis Services开发人员，详细介绍了如何使用BIDS以及BIDS的所有功能，提供了使用SSAS构建OLAP多维数据集和数据挖掘模型的指南；第三部分面向Integration Services开发人员，详细介绍如何使用SSIS开发ETL软件包，利用ETL包加载OLAP多维数据集和数据挖掘结构；第四部分详细介绍了SSRS的架构，以及Excel、Visio或Office SharePoint Server 2007作为BI客户端的实现。 《SQL Server 2008商业智能完美解决方案》结合专家团队提供的实际示例和丰富经验进行介绍，让读者能够直观轻松地掌握构建商业智能(BI)解决方案的概念、工具和技术，是一本不可多得的商业智能开发参考指南。无论是商业智能(BI)编程新手还是经验丰富的老手，都可从《SQL Server 2008商业智能完美解决方案》中获益。 目录 -------------------------------------------------------------------------------- 第一部分 面向商业决策者和架构师的商业智能 第1章 商业智能基础 3 1.1 商业智能和数据建模 3 1.2 OLTP和OLAP 4 1.2.1 联机事务处理 4 1.2.2 联机分析处理 6 1.3 常用BI术语 9 1.3.1 数据仓库 9 1.3.2 数据市场 10 1.3.3 多维数据集 11 1.3.4 决策支持系统 11 1.3.5 数据挖掘系统 11 1.3.6 提取、转换和加载系统 12 1.3.7 报表处理系统 12 1.3.8 关键绩效指标 12 1.4 Microsoft BI解决方案的核心组件 12 1.4.1 SQL Server 2008 Analysis Services 13 1.4.2 SQL
Win10IoTUnity:适用于Unity的Windows 10 IoT核心插件
05-03
Win10IoTUnity 适用于Unity的Windows 10 IoT核心插件 这是一个适用于Windows 10 IoT核心API访问的Unity插件的示例。 您可以-并且应该-根据需要修改plugin.cs文件。 当前的插件文件旨在在Unity项目中调用该方法时点亮LED。 该解决方案包含两个项目：一个针对.NET 4.5的“真实”项目，另一个链接至另一个项目中的project.cs文件的“存根”项目。 存根项目的目标是.NET 3.5，并且是Unity所必需的。 编译时，请确保已选择“任何CPU”。 各个DLL的输出路径（或复制路径）应如下所示： 存根项目文件转到[Unity-Project] \ Assets \ Plugins “实际”项目的文件转到[Unity-Project] \ Assets \ Plugins \ WSA 您可能还需要在Unity本身内更改
对于目标文件系统文件过大怎么办_Win10系统提示对于目标文件系统过大
weixin_39682673的博客
11-24 4231
原文链接：Win10系统提示对于目标文件系统过大 - 何宇泽 - 博客园​www.cnblogs.com今天在使用u盘重装Windows 10操作系统的时候，遇到了这个问题，这篇博文解决了我的问题。正文今天在复制MAC系统文件时，系统弹出窗口提示“对于目标文件系统，文件XXX过大”。出现这种情况的原因是FAT32的文件系统不支持复制大于4g的单个文件，而NTFS则是支持大文件，所以我们可通过转换文...
复制移动文件时对于目标文件系统过大怎么办
A_银河之光
09-12 1万+
今天在复制一个文件到U盘的时候，突然弹出了‘对于目标文件系统过大’的对话框，一个4G多的文件就这样不能够被复制到目标目录下了，其实这是目标硬盘的格式不正确的原因，我这个U盘格式是FAT32，应该将其修改成NTFS格式就可以了。修改方法： 点击【开始】然后找到【运行】，或者是直接使用快捷键WIN+R打开运行，然后输入【cmd】点击确定即可。然后输入【convert M:/fs:ntfs】，其中‘M’
win系统，复制文件提示对于目标文件系统过大
Longyu144714的博客
03-04 1208
今天在帮助同事，往U盘上复制文件的时候，系统提示对于目标文件系统，文件XXXXX过大。 原因 U盘的格式是FAST32, FAST32的文件系统不支持大于4G的单个文件 解决 需要将U盘的格式转换为NTFS, 因为该格式的文件系统支持大文件 步骤 1）windows+R或打开开始菜单，搜索CMD, 打开命令提示符 2）找到U盘，确定U盘分区名称，如F：或J： 3） 在命令提示符中输入convert F:/fs:ntfs，按回车键，如下图所示 4）等待执行结束， 如下图所示： 5）此时
对于目标文件系统文件过大
wuyepiaoxue789的博客
06-24 2073
1、改变FAT32为NTFS文件系统，不格式化磁盘前提，运行命令 convert g: /fs:ntfs /x，g为盘符 2、出现提示，再运行 chkdsk g: /f，g为盘符，最后运行convert g: /fs:ntfs /x 即可. ...
对于目标文件系统文件过大怎么办_U盘复制超过4G文件时，对于目标文件系统文件过大怎么办？...
weixin_39942995的博客
11-24 6767
当我准备复制一个系统镜像到我的16GB U盘时，出现以下提示：对于目标文件系统，文件过大。查看了一下U盘容量，还有二十几个GB完全够装下一个4.77GB的系统镜像。为什么会出现无法复制的情况呢？这是因为U盘的文件格式一般为FAT32当向U盘复制超过4GB大小的文件时就会出现这个提示。而在电脑硬盘中复制超过4GB文件就没有这个提示，因为硬盘的格式一般为NTFS，支持大文件复制。那么怎么解决呢。？我们...
桃源企业文件管理系统 v3.3.zip
07-08
桃源企业文件管理系统3.3更新说明： 增加手机HTML5版，手机可扫描首页二维码访问或通过http://网址/html5/访问（仅商业版提供） 共享的文件和文件夹后台管理员可以设置固顶 插件批量上传也要能够设置重名文件自动更名功能 用户信息中允许登录的IP只能识别一个 选中必须签收才能下载时应该不可以进行复制 先复制再移动相同的文件到同一个目录中时会重复出现 已伪删除或在回收站中的文件提取时还可下载的问题 已伪删除或在回收站中的文件夹用上传码时还可上传的问题 后台修改用户名时若用户名或文件夹已存在则提示 内置office控件编辑时另外一个人无法解除锁定 设置特定排序后左侧目录树和右侧排序不一致问题 IE11下无法选择共享对象的问题 一些浏览器兼容性问题   旧版用户升级方法： 1.上传除web.config文件、data目录之外的所有文件 2.在浏览器地址栏使用http://程序地址/update.aspx（注意为aspx后缀，非asp）方式浏览，看到升级成功字样即升级成功   一、系统特点： 1、强大文件上传：普通模式及浏览器ActiveX插件上传支持单个电子文档最大2G。支持多文件批量上传、断点续传、进度显示上传。 2、超强易用性能：采用BS(浏览器/服务器)模式服务，类WINDOWS操作方案，即使仅会用鼠标的用户也可在无培训情况下快速应用。加强版OFFICE文件的在线编辑和版本管理能力提供强大、丰富、有效的公文处理能力。 3、应用安全可靠：具有灵活的权限分配机制和文档管理体系，提供多层次安全解决方案，最大限度保护了用户关键信息和文件的可靠管理与应用。 4、组织结构：可动态添加管理公司名称、部门结构、工作组、用户，按照本公司的结构组织出来，方便文件按部门或用户流传签收。 5、完美兼容性：兼容firefox等非IE浏览器。 6、海量电子文档存储：支持单服务器多分区、多硬盘、多服务器分布式数据存储，轻松实现海量电子文档的存储服务，支持硬件存储平台。   二、主要功能： 作为一套专业的企业级网络软件，该软件依照微软技术架构体系，采用流行、成熟、安全的三层结构开发，有关产品的主要功能如下： 1、文件及目录操作：前台用户登录后可实现类似windows资源管理器的目录创建、删除和移动，文件上传、下载及文件列表查看，图片预览及多媒体文件在线播放（需安装多媒体播放器），文件剪切、复制、粘贴、改名、删除、注释、导航、压缩、解压缩等操作。 2、无限共享功能：支持目录和单个文件共享操作，共享目标可以选添公司、部门、项目组或指定用户，可设完全、添加、只读等权限控制。被授权的用户则可以通过签收目录或签收文件查看或应用共享内容。 3、多模式文件上传：支持多达5种文件上传模式，包括计算机浏览器普通上传、手机WAP浏览器普通上传（需安装WAP服务组件）、浏览器ActiveX插件批量文件上传、添加文件网址直接下载文件到用户空间、访客持上传码上传文件等。 4、文件预览或编辑：支持各种图片文件即时预览、媒体或flash文件在线播放、文本及PDF文件在线打开，可在后台扩充文件支持格式。可在线编辑TXT、word、excel、PowerPoint等格式文件，编辑后回存服务器，无需下载修改后上传，亦可做到只读显示，无权限人员不可复制、另存。 5、超级文件转发：不限制文件大小，转发内容可为单个或多个文件，勾选转发内容后系统将会把有关文件的下载链接发送到转发目标用户站内短消息或邮件中供其下载。 6、缩略图预览：前台用户当前目录下的所有图片文件以缩略图方式展示，类似windows中的缩略图功能，缩图按比例显示。 7、前台用户子帐号：支持前台用户建立多个同用户名，但密码不同的二级子账号，每个子账号对应相应子目录，系统支持丰富的子账号操作权限配置。有关访客可持二级子账号登陆后，按照该用户设置的权限获得服务系统有关服务。 8、文件回收站功能：前台用户操作中删除的目录或文件均会被转移到回收站，在这里做最后确认后可以删除或清空文件，也可以还原选择的目录或文件，避免误操作损失。 9、公共空间：由后台管理员启用并设置好公共空间各目录名称及共享权限，前台用户登录都可以按照分配给自己的权限（完全、只读、添加等）进入公共空间，能够实现了各个公司、部门、工作组只能查看有权查看的文件，并可按权限进行批阅、添加等操作。 10、访客文件提取及密码上传：访客可持系统前台用户提供的文件提取码进行文件提取操作，也可通过前台用户提供的上传密码向有关前台用户空间指定目录中上传文件。 11、完善的日志记录功能：后台管理员及用户前台的各种操作行为，访客或其它用户对有关用户文件进行的操作均会产生实时操作日志，以便于出现问题追根溯源
精通Windows.API-函数、接口、编程实例.pdf
01-27
仅收录该书籍以供学习和讨论 包含pdf书籍及经过验证的示例 执行demo中的示例方式 在编译环境下进入demo目录，执行nmake命令在bin目录下生成可执行文件 注：demo无注释，对应书本中部分示例。 目录 第1章　Windows应用程序开发入门　1 1.1　第一个实例程序　1 1.1.1　start.exe　1 1.1.2　Windows API　2 1.1.3　程序入口函数　2 1.1.4　start.c代码分析　2 1.2　编译代码　3 1.2.1　安装Visual Studio　3 1.2.2　安装Microsoft Platform SDK　4 1.2.3　集成Microsoft Platform SDK与Visual C++速成版　5 1.2.4　Vista SDK与Visual Studio 2008　6 1.2.5　Visual Studio专业版或团队系统版　7 1.2.6　使用图形化IDE建立工程、进行编译　7 1.2.7　“解决方案”与“工程”　8 1.2.8　使用命令行工具编译　8 第2章　Windows API概要　10 2.1　Windows数据类型　10 2.1.1　Windows数据类型示例　10 2.1.2　Windows数据类型与标准C数据类型的关系　14 2.1.3　Windows数据类型与Windows API　14 2.1.4　Windows中的数据结构　15 2.2　Windows API的功能分类　15 2.2.1　系统基本服务　15 2.2.2　系统管理　17 2.2.3　用户界面　17 2.2.4　图像和多媒体　20 2.2.5　网络　20 2.2.6　系统安全　20 2.2.7　其他功能　21 2.3　Windows API核心DLL　21 2.3.1　Kernel32.dll　21 2.3.2　User32.dll　21 2.3.3　Gdi32.dll　22 2.3.4　标准C函数　22 2.3.5　其他Dll　22 2.4　Unicode和多字节　22 2.4.1　W版本和A版本的API　24 2.4.2　Unicode与ASCII的转换　24 2.5　对Windows程序设计规范的建议　25 第3章　开发工具配置与使用　26 3.1　使用Visual C/C++编译链接工具　26 3.1.1　编译器cl.exe　27 3.1.2　资源编译器rc.exe　31 3.1.3　链接器link.exe　32 3.1.4　其他工具　38 3.1.5　编译链接工具依赖的环境变量　39 3.1.6　示例：使用/D选项进行条件编译　42 3.2　使用Platform SDK　43 3.2.1　Platform SDK的目录结构与功能　43 3.2.2　为编译链接工具设置环境变量　45 3.2.3　Platform SDK工具集　46 3.2.4　Windows Vista SDK　48 3.3　编写Makefile　48 3.3.1　使用nmake.exe构建工程　48 3.3.2　Makefile实例　50 3.3.3　注释　50 3.3.4　宏　50 3.3.5　描述块：目标、依赖项和命令　53 3.3.6　makefile预处理　55 3.3.7　在Platform SDK的基础上使用nmake　56 3.4　使用WinDbg调试　57 3.4.1　安装WinDbg　57 3.4.2　编译可调试的程序　58 3.4.3　WinDbg命令　59 3.4.4　调试过程演示　59 3.5　集成开发环境 Visual Studio　62 3.5.1　工程类型选择与配置　62 3.5.2　Visual Studio快捷方式　64 3.5.3　生成项目　64 3.5.4　调试　65 3.5.5　选项与设置　65 3.6　开发环境配置总结　66 第4章　文件系统　67 4.1　概述　67 4.1.1　文件系统的基本概念　67 4.1.2　文件系统主要API　68 4.2　磁盘和驱动器管理　70 4.2.1　遍历卷并获取属性　70 4.2.2　操作驱动器挂载点　76 4.2.3　判断光驱中是否有光盘　81 4.2.4　获取磁盘分区的总容量、空闲容量、簇、扇区信息　83 4.3　文件和目录管理　86 4.3.1　删除、复制、重命名、移动文件　87 4.3.2　创建、打开、读写文件，获取文件大小　90 4.3.3　创建目录　96 4.3.4　获取程序所在的目录、程序模块路径，获取和设置当前目录　97 4.3.5　查找文件、遍历指定目录下的文件和子目录　100 4.3.6　递归遍历目录树　103 4.3.7　获取、设置文件属性和时间　105 4.4　内存映射文件　110 4.4.1　使用Mapping File提高文件读写的效率　110 4.4.2　通过Mapping File在进程间传递和共享数据　115 4.4.3　通过文件句柄获得文件路径　118 4.5　总结　121 第5章　内存管理　122 5.1　Windows内存管理原理　122 5.1.1　基本概念　122 5.1.2　分页与分段内存管理、内存映射与地址转换　123 5.1.3　进程的内存空间　125 5.1.4　虚拟内存布局、内存的分工、堆与栈　127 5.1.5　内存的保护属性和存取权限　127 5.1.6　本章API列表　127 5.2　堆管理　129 5.2.1　获取堆句柄、分配与再分配堆　129 5.2.2　获取堆中内存块的大小信息　133 5.2.3　释放内存、销毁堆　134 5.3　全局(Global)和局部(Local)内存管理　136 5.3.1　Global函数　136 5.3.2　Local函数　137 5.3.3　使用全局和局部函数分配和释放内存、改变内存块属性　137 5.4　虚拟内存管理　138 5.4.1　虚拟地址空间与内存分页　139 5.4.2　分配和释放可读可写的虚拟内存页面　139 5.4.3　修改内存页面状态和保护属性、将页面锁定在物理内存中　142 5.4.4　管理其他进程的虚拟内存　143 5.5　内存操作与内存信息管理　144 5.5.1　复制、填充、移动、清零内存块、防止缓冲区溢出　144 5.5.2　获得当前系统内存使用情况　146 5.5.3　判断内存指针的可用性　147 5.6　各种内存分配方式的关系与比较　148 5.6.1　标准C内存管理函数与Windows内存管理API的关系　149 5.6.2　功能性区别　149 5.6.3　效率的区别　149 第6章　进程、线程和模块　150 6.1　基本概念　150 6.1.1　应用程序与进程　150 6.1.2　控制台应用程序与图形用户界面应用程序　151 6.1.3　动态链接库、模块　151 6.1.4　线程、纤程与作业　152 6.1.5　权限与优先级　153 6.2　进程管理　153 6.2.1　创建进程、获取进程相关信息、获取启动参数　153 6.2.2　编写控制台程序和图形用户界面应用程序　158 6.2.3　获取和设置环境变量　158 6.3　线程、纤程　162 6.3.1　创建线程、退出线程、获取线程信息　162 6.3.2　挂起、恢复、切换、终止线程　164 6.3.3　创建远程线程、将代码注入其他进程中执行　167 6.3.4　创建纤程、删除纤程、调度纤程　170 6.3.5　纤程与线程的互相转换　171 6.4　进程状态信息　176 6.4.1　PS API与Tool help API　176 6.4.2　遍历系统中的进程　178 6.4.3　列举进程的模块、线程　182 6.4.4　进程的堆使用、内存占用、虚拟内存大小，页面错误情况　184 6.5　动态链接库　185 6.5.1　加载、释放DLL、通过句柄获取DLL相关信息　186 6.5.2　编写动态链接库、导出函数　186 6.5.3　创建动态链接库工程，配置DLL编译链接选项　188 6.5.4　运行时动态获取DLL导出函数地址并调用　189 6.5.5　声明导出函数、创建lib库，为其他模块提供导入表调用接口　190 6.5.6　通过构建导入表调用DLL导出函数　191 第7章　线程同步　192 7.1　基本原理　192 7.1.1　线程同步的过程　193 7.1.2　同步对象　193 7.1.3　等待函数　193 7.2　同步对象示例　194 7.2.1　使用事件对象(Event)　194 7.2.2　使用互斥对象(Mutex)　199 7.2.3　使用信号量控制访问共享数据的线程数量　202 7.2.4　使用可等待计时器(Timer)　206 7.3　等待进程和线程的执行完成　209 第8章　服务　210 8.1　基本概念　210 8.1.1　服务控制器(SCM)　211 8.1.2　服务程序　211 8.1.3　服务控制管理程序　211 8.1.4　系统服务管理工具　211 8.1.5　服务的属性　211 8.2　编写服务程序　212 8.2.1　入口函数　212 8.2.2　服务主函数　212 8.2.3　控制处理函数　213 8.3　实现对服务的控制和管理　216 8.3.1　创建、删除服务　216 8.3.2　启动、停止服务，向服务发送控制请求　219 8.3.3　管理服务状态、配置服务、服务的依赖关系　222 第9章　图形用户界面　229 9.1　字符界面程序　229 9.1.1　基本概念　230 9.1.2　控制台读写　231 9.1.3　控制台字体、颜色等属性，操作屏幕缓存　234 9.1.4　控制台事件　244 9.2　图形用户界面：基本概念　246 9.2.1　窗口　246 9.2.2　窗口类　246 9.2.3　消息和消息处理函数　247 9.2.4　控件　247 9.2.5　资源　248 9.2.6　对话框　248 9.3　图形用户界面：窗口　248 9.3.1　注册窗口类　249 9.3.2　创建窗口　251 9.3.3　窗口消息处理函数　253 9.3.4　窗口属性、位置和大小　256 9.3.5　窗口显示方式　257 9.3.6　线程消息队列和消息循环　258 9.4　图形用户界面：控件　258 9.4.1　Tree View控件　258 9.4.2　为Tree View控件增加节点　260 9.4.3　Tree View右键菜单　262 9.4.4　List View控件　263 9.4.5　为List View控件增加分栏　265 9.4.6　为List View控件增加项　266 9.4.7　文本框控件　267 9.4.8　为文本框控件设置文字　268 9.5　界面资源　269 9.5.1　资源脚本(.rc)　269 9.5.2　资源ID定义和头文件　272 9.5.3　在程序中使用资源　273 9.6　菜单　273 9.6.1　菜单资源和菜单句柄　273 9.6.2　动态增加、删除、设置菜单及菜单项　274 9.6.3　菜单消息处理　274 9.7　对话框　275 9.7.1　创建对话框　275 9.7.2　对话框消息处理函数　276 第10章　系统信息的管理　277 10.1　Windows系统信息　277 10.1.1　获取系统版本　277 10.1.2　获取计算机硬件信息　279 10.1.3　获取系统目录等信息　281 10.1.4　用户名、计算机名、域名　282 10.1.5　处理系统颜色信息、尺度信息等　284 10.1.6　鼠标、键盘等外设信息　285 10.2　时间信息　286 10.2.1　设置、获取系统时间　286 10.2.2　获取开机至现在持续的时间　287 10.2.3　文件时间与系统时间的转换　287 10.3　注册表　288 10.3.1　注册表的作用及组织形式　288 10.3.2　键、子键、键属性及键值的相关操作　289 10.3.3　列举注册表项及键值　292 10.3.4　通过注册表设置一个自启动的程序　293 10.3.5　设置随程序启动而启动的调试器(任何程序)　294 10.3.6　指定程序崩溃实时调试器　294 第11章　进程间通信　295 11.1　邮槽(MailSlot)　295 11.1.1　创建邮槽、从邮槽中读取消息　296 11.1.2　通过邮槽发送消息　299 11.2　管道(Pipe)　300 11.2.1　创建命名管道　300 11.2.2　管道监听　302 11.2.3　使用异步I/O进行读写　303 11.2.4　关闭管道实例　307 11.2.5　客户端　307 11.3　剪贴板　310 11.3.1　获取、设置剪贴板数据　310 11.3.2　监视剪贴板　317 11.3.3　剪贴板数据格式　325 11.4　数据复制消息(WM_COPYDATA)　327 11.4.1　数据发送端　327 11.4.2　数据接收端　330 11.5　其他进程间通信方式　332 11.5.1　动态数据交换(DDE)和网络动态数据交换(NDDE)　332 11.5.2　通过File Mapping在进程间共享数据　333 11.5.3　Windows Socket　333 第12章　Windows Shell程序设计　334 12.1　Windows Shell目录管理　335 12.1.1　Shell对目录和文件的管理形式　335 12.1.2 “我的文档”等特殊目录相关操作　335 12.1.3　绑定、遍历、属性获取　337 12.1.4　浏览文件对话框　339 12.2　文件协助(File Associations)　340 12.2.1　文件类型相关注册表键值　340 12.2.2　为文件指定默认打开程序　341 12.2.3　定制文件类型的图标　342 12.3　Shell扩展　343 12.3.1　对象及概念　343 12.3.2　CLSID，处理例程的GUID　344 12.3.3　注册Shell扩展　345 12.3.4　COM程序开发基础　346 12.3.5　编写Handler程序　346 12.3.6　Shell扩展程序的调试　362 12.3.7　总结　363 12.4　任务栏通知区域(Tray)图标　363 12.4.1　创建图标窗口　364 12.4.2　创建图标和图标菜单　367 12.4.3　最小化主窗口到通知区域　370 12.4.4　弹出气泡通知　372 12.4.5　动态图标　374 12.4.6　其他功能　376 第13章　Windows GDI　379 13.1　GDI编程接口概述　379 13.1.1　Windows GDI的功能　379 13.1.2　链接库与头文件　380 13.2　设备上下文(DC)、输出操作与图形对象　380 13.2.1　设备上下文类型与关联设备　380 13.2.2　图形对象的作用及与DC的关系　380 13.2.3　各类图形对象的具体属性与作用　383 13.2.4　绘制、填充、写入等图形输出操作　384 13.2.5　修剪与坐标变换　385 13.2.6　设备上下文的图形模式　385 13.3　一个最简单的GDI程序　386 13.3.1　示例　386 13.3.2　DC的操作　387 13.3.3　颜色的表示　388 13.3.4　图形对象：画刷和画笔　389 13.3.5　输出操作：绘制图形和线条　390 13.4　文字和字体　391 13.4.1　选择、设置字体　393 13.4.2　选择字体图形对象　394 13.4.3　文字的颜色　394 13.4.4　输出文字　395 13.4.5　DC图形模式设置　395 13.4.6　遍历字体　396 13.4.7　为系统安装、删除字体文件　398 13.5　绘制线条　398 13.5.1　选择画笔对象　399 13.5.2　直线　399 13.5.3　绘制任意曲线　399 13.5.4　跟踪鼠标轨迹　399 13.5.5　弧线　405 13.6　绘制图形　405 13.6.1　填充颜色与边缘勾勒　406 13.6.2　绘制矩形、椭圆、圆角矩形　406 13.6.3　椭圆弓形和椭圆扇形　411 13.6.4　多边形　411 13.6.5　RECT结构及对RECT的操作　412 13.7　位图操作　414 13.7.1　截取屏幕、保存位图文件　414 13.7.2　将位图显示在界面上　419 13.8　区域(Regions)、路径(Paths)与修剪(Clip)操作　422 13.8.1　区域的创建及形状、位置等属性　422 13.8.2　区域边沿、区域填充、反转与勾勒操作　423 13.8.3　组合、比较、移动等操作　426 13.8.4　点击测试(Hit Testing)　427 13.8.5　路径的创建与操作　431 13.8.6　路径转换为区域　432 13.8.7　使用区域和路径进行修剪操作，限制输出　432 13.9　坐标变换　438 13.9.1　缩放　439 13.9.2　旋转　440 13.10　调色板　440 第14章　网络通信与配置　443 14.1　Socket通信　444 14.1.1　客户端　444 14.1.2　服务端　449 14.1.3　处理并发的客户端连接　455 14.1.4　网络通信的异步I/O模式　456 14.2　IP Helper　456 第15章　程序安装与设置　463 15.1　创建cab文件　463 15.1.1　makecab.exe　463 15.1.2　压缩多个文件　464 15.1.3　Cabinet软件开发工具包(CABSDK)　466 15.2　编写INF文件　466 15.2.1　INF文件格式　466 15.2.2　Install节　468 15.2.3　CopyFiles和AddReg等安装过程　468 15.2.4　源路径和目的路径　469 15.2.5　字符串表　469 15.3　安装程序setup.exe的编号　469 15.4　使用msi文件进行安装　472 15.4.1　Windows Installer Service　472 15.4.2　msi文件的创建与修改工具orca.exe　474 15.4.3　准备工作　475 15.4.4　编辑表组　475 第16章　设备驱动管理与内核通信　476 16.1　设备管理　476 16.1.1　列举设备接口　477 16.1.2　监控设备的加载和卸载　483 16.2　I/O控制、内核通信　488 16.2.1　加载驱动程序　488 16.2.2　控制驱动程序、与驱动程序进行通信　495 16.3　编写设备驱动程序　498 16.3.1　驱动程序开发包：DDK　499 16.3.2　开发驱动程序　499 16.4　I/O模式，同步与异步　504 第17章　用户、认证和对象安全　506 17.1　基本概念　506 17.1.1　访问令牌、权限和用户标识　506 17.1.2　进程的系统操作权限　507 17.1.3　安全对象　508 17.1.4　访问控制列表(ACL)　508 17.2　安全机制程序示例　509 17.2.1　列举进程访问令牌内容和权限　509 17.2.2　修改进程的权限　514 17.2.3　列举安全对象的安全描述符　515 17.2.4　修改安全描述符　521 17.3　用户　522 17.3.1　创建用户　522 17.3.2　用户组　523 17.3.3　删除用户　525 17.3.4　列举用户和用户组、获取用户信息　525 第18章　Windows API的内部原理　532 18.1　关于API的补充说明　532 18.1.1　Windows API的版本演进和Vista新增API　532 18.1.2　64位操作系统的接口　533 18.2　Windows系统中的对象封装　533 18.2.1　什么是对象　534 18.2.2　面向对象的思想　534 18.2.3　Windows系统中的对象：内核对象、GDI对象等　534 18.3　Windows程序设计参考：文档资源与样例代码　534 18.3.1　SDK文档和MSDN　534 18.3.2　SDK示例代码　535 18.4　x86平台程序函数调用原理　535 18.4.1　函数调用的真实过程　535 18.4.2　函数调用约定　539 18.4.3　为什么通过参数返回数据时只能使用指针　540 18.4.4　缓冲区溢出　540 18.4.5　程序运行错误的调试技巧　540 18.5　可执行程序结构与API函数接口内部机理　541 18.5.1　Windows可执行程序结构　541 18.5.2　导入表、导出表、动态链接　543 18.5.3　NTDLL.DLL、NATIVE API和SSDT　544 18.5.4　API HOOK　546 18.6　发布程序　546 18.6.1　合理选择编译链接选项　546 18.6.2　构建到指定路径　546 18.7　模块化，向Windows API学习接口定义　547 18.7.1　lib文件　547 18.7.2　头文件　547 18.7.3　为第三方应用软件提供SDK　547
计算机文件无法移动,电脑上不能拖动文件怎么办 电脑上不能拖动文件如何解决...
weixin_33622153的博客
07-04 1万+
首先可以试试连按两次键盘左上角的ESC键，如果不行再同时按下【win+r】弹出运行窗口，然后在运行输入框中输入【gpedit.msc】点击确定，在弹出的【本地组策略编辑器】窗口中，打开【用户配置】列表下的【管理模板】，再找到并双击【windows组件】，接着在右边找到并双击【任务计划程序】选项，在弹出的窗口中，双击【禁止拖放】，最后禁止拖放窗口中点击选项【未配置】或着【已禁用】选项，点击应用和确定...
向U盘传输文件时，出现"对于目标文件系统，文件* * * * * * * 过大"
巴卡巴卡哇的博客
05-12 1万+
原因：FAT32格式的U盘只能传输单个文件大小小于4G的文件。 知识点：U盘或者操作系统的存储文件格式有三种：FAT32、NTFS、exFAT 1、FAT32 概念：FAT32文件系统用4个字节（32位）空间来表示每个扇区配置文件的情形，所以叫FAT32。分区容量最低是512M，而上限的话不同的操作系统都不一样，WinXP系统最大可以做到2TB的FAT32分区。 大多说用户...
mac复制文件提示cp: /Volumes/WINDOWS11/sources/install.wim: File too large
IDO老徐软件测试窝
03-25 1113
如果提示cp: /Volumes/WINDOWS11/sources/install.wim: File too large说明，你们的 U盘 或者磁盘，格式不对 。需要从 FAT32 改为 ExFAT更改步骤，见 上一篇https://www.jianshu.com/p/e3009fde99e6...
对于目标文件系统，文件过大怎么办
Jennifer4869的博客
03-02 9604
复制比较大的文件出现“对于目标文件系统，文件XXX过大”。这是因为FAT32的文件系统不支持复制大于4g的单个文件，所以要转换为支持大文件的NTFS文件系统。第一种方法：右键格式化，修改文件系统为NTFS接下来就可以复制了。第二种方法：我的u盘是E盘，所以在命令提示符中输入“convert E:/fs:ntfs”,等待一会也就可以复制了。...
对于目标文件系统文件过大怎么办_用了这么多年Ext4文件系统，您知道它的这些高级特性吗？...
weixin_39639174的博客
11-24 181
Ext4文件系统大家都非常熟悉了，也是一个老牌的文件系统，它在2006年11月随2.6.19内核初次发布，到2008年12月25日，Linux Kernel 2.6.28的正式版本发布，Ext4文件系统基本稳定，也称为很多发行版的默认文件系统。算起来到现在也有十几年了。我们经常使用Ext4文件系统，不管是普通办公用的笔记本或者PC，还是服务器，很多根文件系统就是Ext4，但Ext4到底相对于Ext...
u盘容量足够，但是提示目标文件过大无法复制的解决办法
sunweiking的博客
03-05 6521
一般来说，fat32格式的U盘只允许拷贝或者创建单个小于4G的文件，如果拷贝单个文件4G以上的文件，需要将U盘的fat32格式转换成ntfs格式。在命令提示符界面窗口中,输入“convert g:/fs:ntfs”并回车确定(这边g:/代表U盘所在盘符,你需要根据你电脑中的U盘实际情况正确输入盘符)。转换完成之后复制可以成功。 ...
windows系统“文件访问被拒绝，你需要提供管理员权限才能删除此文件”的解决方案
热门推荐
光头强的博客
04-17 11万+
windows系统“文件访问被拒绝，你需要提供管理员权限才能删除此文件”的解决方案。
win11用批处理指令拷贝bat文件到C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp\为什么文件不可用或者是空的
最新发布
05-17
您可以尝试手动复制文件到目标路径，看是否可以成功。 3. 如果您使用了一些特殊字符或空格，需要在指令中使用引号将路径括起来，例如： ``` copy "C:\path\to\your\file.bat" "C:\ProgramData\Microsoft\Windows...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值