C语言内存管理
计算机系统基础 c语言视角
计算机系统基础 c语言视角计算机系统基础从C语言视角计算机系统基础是计算机科学与技术的一门重要课程，它涉及计算机硬件和软件的基本原理与概念。
C语言作为一种广泛应用于系统编程的高级程序设计语言，对于学习计算机系统基础具有重要的视角。
本文将从C语言的角度出发，探讨计算机系统基础的相关内容。
一、C语言的基本特性C语言是一种面向过程的编程语言，其特点是简洁、高效、灵活。
它提供了丰富的数据类型和操作符，并且具有良好的可移植性。
C 语言的程序结构由函数组成，通过函数的调用和返回来完成程序的执行。
这种结构与计算机系统中的指令执行和函数调用非常契合，因此C语言在系统编程中得到了广泛的应用。
二、C语言的内存管理在计算机系统中，内存管理是一个重要的概念。
C语言提供了灵活的内存管理机制，程序员可以手动申请和释放内存空间。
通过使用malloc函数申请内存，程序员可以根据需要动态地分配内存空间。
而通过free函数释放内存，可以避免内存泄漏的问题。
这种内存管理方式为程序的运行效率和资源利用提供了支持。
三、C语言的指针操作指针是C语言中的重要概念，它提供了直接访问内存地址的能力。
指针的使用可以实现对内存中数据的直接操作，提高程序的执行效率。
通过指针操作，可以实现数据的传递和共享，进一步优化系统的性能。
指针还可以与数组和结构体等数据结构进行灵活的组合，实现更复杂的数据操作。
四、C语言的位操作位操作是计算机系统中常用的一种操作方式，它可以对数据的位进行精确的控制。
C语言提供了位操作的运算符，可以对数据的每一位进行与、或、异或等操作。
通过位操作，可以实现对数据的压缩和解压缩，提高存储空间的利用率。
位操作还可以实现数据的快速查找和处理，提高系统的性能。
五、C语言的文件操作文件操作是计算机系统中必不可少的一部分。
C语言提供了丰富的文件操作函数，可以对文件进行读写和管理。
通过文件操作，可以实现数据的永久存储和共享。
C语言的文件操作机制为系统的文件管理提供了良好的支持。
大学c语言知识点笔记 大学c语言基础考试知识点
大学C语言知识点笔记C语言是一门非常重要的编程语言，广泛应用于各个领域。
在大学学习C语言是非常重要的一环，因为它是计算机科学和软件工程领域的基础。
本文将总结大学C语言基础考试知识点，希望能够帮助各位同学更好地备考。
1. 基本语法C语言的基本语法是了解C语言的第一步。
下面列举一些常见的基本语法知识点：•变量和数据类型：如何声明变量，各种数据类型的特点和使用方法。
•运算符：算术运算符、逻辑运算符、关系运算符等。
•控制结构：条件语句（if-else语句、switch语句）、循环语句（for 循环、while循环、do-while循环）。
•函数：函数的定义和调用，函数参数的传递。
•数组：一维数组和二维数组的定义和使用。
•指针：指针的基本概念，指针的声明和使用，指针与数组的关系。
•结构体：结构体的定义和使用。
2. 程序设计C语言的程序设计是非常重要的一环，它涉及到如何用C语言解决实际问题。
下面列举一些常见的程序设计知识点：•算法和流程图：如何使用伪代码描述算法，如何使用流程图表示问题的解决过程。
•函数的设计：如何设计一个函数，如何将一个大问题划分为多个小问题，如何通过函数的调用和返回来解决问题。
•递归：递归函数的概念、递归函数的实现和调用。
•文件的读写：如何打开文件、读取文件、写入文件。
•链表：链表的定义和基本操作，如何使用链表解决问题。
•排序和查找：各种排序算法（冒泡排序、快速排序、插入排序）和查找算法（二分查找、顺序查找）的原理和实现。
3. 内存管理C语言中的内存管理是非常重要的一部分，它直接影响到程序的性能和稳定性。
下面列举一些常见的内存管理知识点：•变量的作用域和生命周期：局部变量和全局变量的作用域范围和生命周期。
•内存分配和释放：动态内存分配的原理和使用方法，如何使用malloc函数来申请内存，如何使用free函数来释放内存。
•内存泄漏和野指针：内存泄漏和野指针的概念和原因，如何避免内存泄漏和野指针的产生。
c语言函数 malloc 与free 实现
c语言函数malloc 与free 实现在C语言中，malloc和free是用于动态内存分配和释放的两个重要函数。
这两个函数允许程序在运行时动态地分配和释放内存，使得程序更加灵活。
本文将深入探讨malloc和free函数的实现原理以及在实际编程中的应用。
1. malloc函数的实现1.1 malloc函数概述malloc（Memory Allocation的缩写）函数用于在堆区分配指定大小的内存空间。
其声明如下：void*malloc(size_t size);其中，size参数表示要分配的内存字节数。
malloc返回一个指向分配内存的指针，如果分配失败，则返回NULL。
1.2 malloc函数的实现原理malloc的实现通常基于操作系统提供的底层内存分配机制。
以下是一个简化的malloc实现示例：#include <stddef.h>void*malloc(size_t size){// 调用底层操作系统的内存分配函数void*ptr =os_allocate_memory(size);return ptr;}上述代码中，os_allocate_memory是一个虚构的函数，实际上会调用操作系统提供的内存分配函数，如brk或mmap等。
malloc返回操作系统分配的内存地址。
2. free函数的实现2.1 free函数概述free函数用于释放通过malloc分配的内存空间。
其声明如下：void free(void*ptr);其中，ptr是由malloc返回的指针。
调用free后，该内存空间将被释放，并可用于后续的内存分配。
2.2 free函数的实现原理free的实现通常涉及将释放的内存块标记为可用，并合并相邻的可用块，以防止内存碎片化。
以下是一个简化的free实现示例：#include <stddef.h>void free(void*ptr){// 标记释放的内存块为可用mark_memory_as_free(ptr);// 合并相邻的可用块coalesce_free_blocks();}上述代码中，mark_memory_as_free是一个虚构的函数，表示将释放的内存块标记为可用。
深入理解C语言技术的使用原理
深入理解C语言技术的使用原理C语言作为一种广泛应用的编程语言，深入理解其使用原理对于程序员来说至关重要。
本文将从不同角度探讨C语言技术的使用原理，帮助读者更好地掌握和应用这门语言。
一、C语言的基本原理C语言的基本原理是通过编写代码来实现计算机程序的功能。
C语言以其简洁、高效的特点而备受程序员的喜爱。
理解C语言的基本原理，需要掌握其基本语法、数据类型、运算符和控制结构等。
1.基本语法：C语言的基本语法包括变量声明、函数定义、语句和表达式等。
变量声明用于定义变量的类型和名称，函数定义用于定义函数的名称、参数和返回值类型。
语句是一组执行特定任务的代码，而表达式则用于计算值。
2.数据类型：C语言提供了多种数据类型，包括整型、浮点型、字符型和指针等。
不同的数据类型适用于不同的场景，程序员需要根据实际需求选择合适的数据类型。
3.运算符：C语言提供了多种运算符，包括算术运算符、关系运算符、逻辑运算符和位运算符等。
运算符用于执行特定的计算或比较操作，帮助程序员实现复杂的逻辑。
4.控制结构：C语言提供了多种控制结构，包括顺序结构、选择结构和循环结构等。
控制结构用于控制程序的执行流程，实现条件判断和循环操作。
二、C语言的内存管理原理C语言的内存管理是其使用原理中的重要部分。
理解C语言的内存管理原理，有助于程序员优化内存使用，提高程序的性能和稳定性。
1.栈和堆：C语言中的变量可以存储在栈或堆中。
栈是一种后进先出的数据结构，用于存储局部变量和函数调用信息。
堆是一种动态分配的内存区域，用于存储动态分配的变量和数据结构。
2.内存分配和释放：C语言提供了malloc()和free()函数用于动态分配和释放内存。
程序员需要手动管理动态分配的内存，确保及时释放不再使用的内存，以避免内存泄漏和内存溢出等问题。
3.指针和引用：C语言中的指针和引用是内存管理的关键概念。
指针是存储内存地址的变量，可以通过指针访问和修改内存中的数据。
引用是对变量的别名，可以用于简化代码和提高效率。
C语言内存管理内存泄漏和内存溢出的预防与处理
C语言内存管理内存泄漏和内存溢出的预防与处理C语言内存管理：内存泄漏和内存溢出的预防与处理内存管理是编程中非常重要的一个方面，而C语言作为一门强大的编程语言，其对于内存的管理也至关重要。
本文将介绍C语言中内存泄漏和内存溢出的概念，并提供预防和处理这些问题的方法。
一、内存泄漏1.1 内存泄漏的定义内存泄漏是指在程序运行过程中，分配的内存空间由于某种原因没有被释放，导致这部分内存无法再被其他程序或者操作系统使用。
随着时间的推移，内存泄漏会导致系统总内存的逐渐减少，最终可能引发程序崩溃或者系统异常。
1.2 内存泄漏的原因内存泄漏主要由以下几个原因引起：- 动态内存分配后忘记释放：使用malloc、calloc或realloc等函数分配内存后，如果没有使用free来释放相应的内存块，就会造成内存泄漏。
- 指针赋值问题：将某个指针赋值给其他变量，导致无法访问该指针所指向的内存区域，进而产生内存泄漏。
- 函数返回值不释放：如果函数返回了一个动态分配的内存块，但没有在适当的地方释放该内存块，就会造成内存泄漏。
1.3 预防内存泄漏的方法为了预防内存泄漏，我们可以采取以下措施：- 在使用malloc、calloc或realloc等函数分配内存后，一定要记得使用free来释放已分配的内存。
- 对于函数的返回值是动态分配的内存块的情况，需要确保在使用完毕后正确释放相应的内存。
- 确保指针赋值不会导致对原有内存块的丢失，避免出现悬空指针。
1.4 处理内存泄漏的方法如果发现程序存在内存泄漏问题，可以采取以下方法进行处理：- 使用内存泄漏检测工具：可以使用一些工具来检测程序中的内存泄漏问题，如Valgrind等，这些工具可以帮助我们找到潜在的内存泄漏点。
- 代码审查：定期进行代码审查，查找是否存在未释放的内存块，并及时修复这些问题。
- 使用析构函数：对于使用面向对象编程的语言，可以通过使用析构函数在对象销毁时释放相应的内存。
C语言操作系统编程进程管理和内存管理
C语言操作系统编程进程管理和内存管理1. 概述操作系统是计算机系统中最核心的软件之一，它负责管理计算机的硬件资源并提供应用程序运行的环境。
编写操作系统需要掌握底层硬件知识、算法与数据结构以及编程语言。
本文将重点介绍C语言在操作系统编程中的进程管理和内存管理实践。
2. 进程管理2.1 进程与线程的概念在操作系统中，进程是指一个正在运行的程序实例，它具有自己的内存空间、代码、数据和文件等资源。
线程是进程的执行单元，一个进程可以拥有多个线程，它们共享进程的资源。
2.2 进程创建和销毁在C语言中，可以利用操作系统提供的API来创建和销毁进程。
常用的API包括`fork()`、`exec()`和`exit()`等。
`fork()`函数可以创建一个新的进程，`exec()`函数可以用新的程序替换当前进程的代码和数据段，`exit()`函数可以正常或异常地退出进程。
2.3 进程调度进程调度决定了系统中哪个进程在什么时候运行。
C语言通过操作系统提供的API进行进程调度，如`sched_yield()`函数可以让出CPU，`sleep()`函数可以使进程进入休眠状态。
此外，还可以使用多线程编程来实现并发执行。
3. 内存管理3.1 内存模型在操作系统中，内存被划分为多个区域，如代码段、数据段、堆和栈等。
C语言程序的内存布局包括：全局变量、静态变量、堆、栈等。
3.2 动态内存分配动态内存分配是指程序在运行过程中根据需要动态地分配和释放内存。
C语言提供了`malloc()`和`free()`函数来实现动态内存分配。
使用时应注意避免内存泄漏和悬空指针等问题。
3.3 内存保护和地址空间操作系统通过内存保护机制来避免不同进程之间的内存访问冲突。
C语言通过指针操作来访问内存，需要合理地使用指针，并通过操作系统提供的API实现内存保护。
4. 示例代码以下是一个简单的示例代码，演示了C语言操作系统编程中的进程管理和内存管理：```c#include <stdio.h>#include <stdlib.h>int main() {// 创建子进程int pid = fork();if (pid < 0) {printf("进程创建失败\n");exit(1);} else if (pid == 0) {// 子进程执行的代码printf("子进程ID：%d\n", getpid()); printf("父进程ID：%d\n", getppid()); exit(0);} else {// 父进程执行的代码printf("父进程ID：%d\n", getpid()); printf("子进程ID：%d\n", pid);}return 0;}```5. 总结本文介绍了C语言操作系统编程中的进程管理和内存管理。
c语言的内存结构
c语言的内存结构C语言是一种高级编程语言，但实际上在计算机中运行时，C语言程序会被编译成可执行文件，然后在计算机内存中运行。
因此，了解C 语言的内存结构对于理解C程序的运行及性能优化至关重要。
C语言的内存结构主要可以分为以下几个部分：栈（Stack）、堆（Heap）、全局内存（Global Memory）和代码区（Code Segment）。
首先是栈（Stack），栈是一种自动分配和释放内存的数据结构。
它用于存储局部变量、函数参数和函数调用信息等。
栈的特点是后进先出（LIFO），也就是最后进入的数据最先被释放。
栈的大小在程序运行时是固定的，一般由编译器设置。
栈的操作速度较快，但内存空间有限。
其次是堆（Heap），堆是一种动态分配和释放内存的数据结构。
它用于存储动态分配的变量、数据结构和对象等。
堆的大小一般由操作系统管理，并且可以在运行时进行动态扩展。
堆的操作相对较慢，因为需要手动分配和释放内存，并且容易产生内存碎片。
全局内存（Global Memory）是用于存储全局变量和静态变量的区域。
全局变量在程序的生命周期内都存在，并且可以在多个函数之间共享。
静态变量作用于其所在的函数内，但是生命周期与全局变量相同。
全局内存由编译器进行分配和管理。
代码区（Code Segment）存储了程序的指令集合，它是只读的。
在程序运行时，代码区的指令会被一条一条地执行。
代码区的大小由编译器决定，并且在程序执行过程中不能修改。
此外，C语言还具有特殊的内存区域，如常量区和字符串常量区。
常量区用于存储常量数据，如字符串常量和全局常量等。
常量区的数据是只读的，且在程序的整个生命周期内存在。
字符串常量区是常量区的一个子区域，用于存储字符串常量。
在C语言中，内存分配和释放是程序员的责任。
通过使用malloc和free等函数，程序员可以在堆中动态地分配和释放内存，从而灵活地管理程序的内存使用。
不过，应当注意避免内存泄漏和野指针等问题，以免出现内存错误和性能问题。
C语言内存分配问题(整理)
我查了下资料，有说分四个，有说分五个加一个程序代码区，我没查到参考的专业书籍。所 以麻烦知道的告知一下，完善一下。
2、 内存分配方式 内存分配方式有三种：
1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整 个运行期间都存在。例如全局变量，static 变量。
4、动态分配释放内存举例 用 malloc 动态分配内存后一定要判断一下分配是否成功，判断指针的值是否为 NULL。 内存分配成功后要对内存单元进行初始化。 内存分配成功且初始化后使用时别越界了。 内存使用完后要用 free（p）释放，注意，释放后，p 的值是不会变的，仍然是一个地址值， 仍然指向那块内存区，只是这块内存区的值变成垃圾了。为了防止后面继续使用这块内存， 应在 free(p)后，立即 p=NULL，这样后面如果要使用，判断 p 是否为 NULL 时就会判断出 来。
NO.2
char *GetMemory(void) {
char Байду номын сангаас[] = hello world; retrun p; } void Test(void) { char *str = NULL; str = GetMemory(); printf(str); }
问题同 NO.1
NO.3
void GetMemory(char **p, int num) {
free(str); if(str != NULL) {
strcpy(str,"world"); printf(str); } }
问题同 NO.1 我对以上问题的分析：
NO.1：程序首先申请一个 char 类型的指针 str,并把 str 指向 NULL（即 str 里存的是 NULL 的地址，*str 为 NULL 中的值为０），调用函数的过程中做了如下动作： 1、申请一个 char 类型的指针 p， 2、把 str 的内容 copy 到了 p 里（这是参数传递过程中系统所做的）, 3、为 p 指针申请了 100 个空间， 4、返回 Test 函数．最后程序把字符串 hello world 拷贝到 str 指向的内存空间里．到这里错 误出现了！ str 的空间始终为 NULL 而并没有实际的空间．深刻理解函数调用的第 2 步，将不难发现问 题所在！（注意：传递的参数和消除的参数） NO.2：程序首先申请一个 char 类型的指针 str,并把 str 指向 NULL．调用函数的过程中做了 如下动作： １申请一数组 p[]并将其赋值为 hello world(数组的空间大小为 12)， ２返回数组名 p 付给 str 指针（即返回了数组的首地址）． 那么这样就可以打印出字符串＂hello world＂了么？当然是不能的！ 因为在函数调用的时候漏掉了最后一步．也就是在第２步 return 数组名后，函数调用还要 进行一步操作，也就是释放内存空间．当一个函数被调用结束后它会释放掉它里面所有的变 量所占用的空间．所以数组空间被释放掉了，也就是说 str 所指向的内容将不确定是什么东 西． NO.3：正确答案为可以打印出 hello．但内存泄漏了！ 需要用 free（）函数进行释放。
C语言技术的高级使用方法
C语言技术的高级使用方法C语言作为一门广泛应用于软件开发和系统编程的编程语言，其高级使用方法在提高代码效率和性能方面起着重要作用。
本文将探讨几种C语言技术的高级使用方法，包括指针操作、内存管理以及多线程编程。
一、指针操作指针是C语言中一种强大的工具，可以直接访问和操作内存中的数据。
高级使用方法包括指针的指针、指针的算术运算以及函数指针等。
1. 指针的指针指针的指针是指指针变量的地址存储在另一个指针变量中。
通过使用指针的指针，可以实现多级间接访问，提高代码的灵活性和效率。
例如，可以使用指针的指针来实现动态数组的分配和释放。
通过在堆上分配一块内存，并将其地址存储在指针的指针中，可以实现动态数组的大小调整。
2. 指针的算术运算指针的算术运算允许对指针进行加减运算，以及比较大小。
这在处理数组和字符串时非常有用。
例如，可以使用指针的算术运算来实现字符串的逆序输出。
通过将指针指向字符串的末尾，然后逐步向前移动指针，可以实现字符串的逆序输出。
3. 函数指针函数指针是指向函数的指针变量。
通过使用函数指针，可以实现回调函数和动态函数调用等高级功能。
例如，可以使用函数指针来实现回调函数，即将一个函数作为参数传递给另一个函数。
这在事件处理和异步编程中非常有用。
二、内存管理C语言中的内存管理是一项关键任务，直接影响程序的性能和稳定性。
高级使用方法包括动态内存分配、内存池和内存映射文件等。
1. 动态内存分配动态内存分配允许在程序运行时分配和释放内存。
通过使用动态内存分配函数（如malloc和free），可以根据需要动态调整内存的大小。
例如，可以使用动态内存分配来实现链表数据结构。
通过在每个节点中使用指针来指向下一个节点，可以实现动态增删节点的功能。
2. 内存池内存池是一种预先分配一定数量内存块的技术。
通过使用内存池，可以减少动态内存分配和释放的次数，提高程序的效率。
例如，可以使用内存池来管理大量的小对象。
通过将内存分为固定大小的块，并将这些块链接在一起，可以实现高效的内存分配和释放。
C语言技术中的内存管理工具推荐与使用
C语言技术中的内存管理工具推荐与使用在C语言开发中，内存管理是一个至关重要的方面。
良好的内存管理可以提高程序的性能和稳定性，而糟糕的内存管理则可能导致内存泄漏和程序崩溃等问题。
为了帮助开发人员更好地管理内存，许多内存管理工具被开发出来。
本文将介绍几种常用的C语言内存管理工具，并讨论它们的推荐与使用。
1. ValgrindValgrind是一个开源的内存调试和性能分析工具。
它可以检测内存泄漏、越界访问、未初始化变量等常见的内存错误。
Valgrind通过在运行时对程序进行动态分析，可以提供详细的报告，帮助开发人员快速定位和修复问题。
它还可以进行性能分析，帮助找出程序的瓶颈。
Valgrind是一个强大而灵活的工具，非常适合C语言开发人员使用。
2. AddressSanitizerAddressSanitizer是LLVM编译器的一个内存错误检测工具。
它可以在编译时插入额外的代码，动态地检测内存访问错误，如缓冲区溢出和使用已释放的内存等。
AddressSanitizer提供了精确的错误报告，可以帮助开发人员快速定位和修复问题。
它还可以检测数据竞争和使用未初始化的变量等问题。
AddressSanitizer是一个高效且易于使用的工具，非常适合C语言开发人员进行内存错误检测。
3. Electric FenceElectric Fence是一个简单而有效的内存调试工具。
它通过在程序的每个内存分配处插入额外的代码，跟踪内存的使用情况。
当程序访问已释放的内存时，Electric Fence会引发一个异常，从而帮助开发人员快速定位问题。
Electric Fence还可以检测堆栈溢出和使用未初始化的内存等问题。
虽然Electric Fence的功能相对较少，但它非常易于使用，适合初学者和小型项目使用。
4. Boehm-Demers-Weiser Garbage CollectorBoehm-Demers-Weiser（BDW）垃圾收集器是一个开源的内存管理库，可以自动回收不再使用的内存。
c语言中内存分配的几种方式
c语言中内存分配的几种方式
在C语言中，内存的管理是非常重要的。
C语言提供了多种内存分配的方式，可以根据不同情况选择不同的方式进行内存分配。
以下是C语言中内存分配的几种方式。
1. 静态内存分配
静态内存分配是在程序编译时就确定了内存的大小和分配位置，这种方式不需要在程序运行时进行内存分配。
在C语言中，静态内存分配可以通过定义全局变量或静态变量来实现。
2. 栈内存分配
栈内存分配是指在函数内部定义的变量所分配的内存。
当函数被调用时，栈被分配一段内存用来存储函数的局部变量，当函数返回时，这段内存会被释放。
栈内存分配的好处是速度快，但是分配的内存大小受限于栈的大小。
3. 堆内存分配
堆内存分配是指程序在运行时通过malloc()函数或calloc()函数动态分配内存。
堆内存的好处是大小灵活，但是需要手动释放，否则容易出现内存泄漏的问题。
4. 内存映射文件
内存映射文件是指将一个文件映射到内存中，使得程序可以直接访问文件中的数据。
在C语言中，可以使用mmap()函数将文件映射到内存中。
总结
在C语言中，内存的管理是非常重要的。
根据不同的情况可以选择不同的内存分配方式，如静态内存分配、栈内存分配、堆内存分配和内存映射文件等。
合理的内存管理可以提高程序的性能和稳定性。
C内存管理智能指针与RAII的应用
C内存管理智能指针与RAII的应用C语言是一门强大而受欢迎的编程语言，但它也因为缺乏自动内存管理而给开发者带来了很多困扰。
为了解决这一问题，C++引入了智能指针和资源获取即初始化（RAII）的概念。
在本文中，我们将讨论C 内存管理中智能指针和RAII的应用。
1. 智能指针的概念与使用智能指针是一个类模板，用于管理动态分配的内存。
它重载了指针操作符，能够像原始指针一样访问对象，同时在对象不再需要时自动释放所占用的内存。
在C++中，智能指针的典型代表是std::unique_ptr 和std::shared_ptr。
在C内存管理中，我们可以借鉴智能指针的概念来实现内存的自动管理。
通过定义一个结构体或者类来封装原始指针，并在析构函数中释放内存，我们可以实现类似于智能指针的功能。
下面是一个使用智能指针的例子：```c#include <stdio.h>#include <stdlib.h>typedef struct {int *data;} SmartPointer;SmartPointer *createSmartPointer(int value) {SmartPointer *sp = (SmartPointer *)malloc(sizeof(SmartPointer)); sp->data = (int *)malloc(sizeof(int));*(sp->data) = value;return sp;}void destroySmartPointer(SmartPointer *sp) {free(sp->data);free(sp);}int main() {SmartPointer *sp = createSmartPointer(10);printf("%d\n", *(sp->data));destroySmartPointer(sp);return 0;}```在这个例子中，我们使用一个SmartPoint结构体来封装原始指针，并在创建结构体时动态分配内存。
C语言与汇编语言的区别
C语言与汇编语言的区别C语言和汇编语言是计算机编程中常用的编程语言，两者在语法、执行方式和应用领域等方面存在明显区别。
本文将分析C语言与汇编语言的区别，从语法结构、可读性、内存管理、执行效率和应用场景等多个角度进行比较。
一、语法结构与可读性C语言是一种高级编程语言，其语法结构更接近自然语言，易于理解和编写。
C语言程序使用变量、控制结构和函数等抽象的方式，使得代码更加简洁和易读。
而汇编语言属于低级语言，其语法结构更加底层，需要直接操作寄存器和内存地址等硬件级别的概念。
汇编语言的代码相对冗长和晦涩，对初学者来说理解和编写难度较大。
二、内存管理C语言提供了丰富的内存管理功能，开发者可以使用指针来动态分配和释放内存，灵活地进行内存管理。
C语言使用变量名来引用和操作内存中的数据，开发者无需考虑底层的地址和寄存器操作，大大简化了程序的开发和维护过程。
而汇编语言需要开发者手动管理内存地址和寄存器，对内存的操作更为直接和底层，需要更深入地理解计算机的硬件结构和指令集。
三、执行效率由于C语言运行在虚拟机上，需要经过编译和链接等过程，因此其执行效率相对较低。
C语言编译后会产生汇编代码，再由汇编器将其转换为机器码执行。
而汇编语言直接操作硬件层级的指令，执行效率更高，可以更好地利用计算机的硬件资源，对于对性能要求较高的程序来说，使用汇编语言能够更好地优化执行速度。
四、应用场景由于C语言易读易写的特点，以及具备较高的可移植性，广泛应用于各个领域。
C语言适用于开发操作系统、应用软件、嵌入式系统和网络通信等项目。
汇编语言则主要应用于特定的硬件驱动程序开发、操作系统底层开发和对性能要求极高的场景下。
汇编语言在性能优化、资源控制和底层硬件驱动等方面具有优势。
综上所述，C语言和汇编语言在语法结构、可读性、内存管理、执行效率和应用场景等方面存在明显区别。
开发者可以根据实际需求和项目特点来选择使用C语言还是汇编语言，以达到最佳的开发效果和性能表现。
C语言内存管理堆栈和静态存储区
C语言内存管理堆栈和静态存储区C语言内存管理：堆、栈和静态存储区C语言作为一种高效而强大的编程语言，其内存管理是程序员必须掌握的重要内容之一。
本文将重点介绍C语言中的内存管理中的堆、栈以及静态存储区。
一、堆堆是C语言中用于动态内存分配的一块内存区域。
在程序运行时，可以通过函数malloc()和calloc()来申请堆空间，通过函数free()来释放堆空间。
堆的特点：1. 大小可变：堆中的内存空间大小可以在程序运行时进行动态调整。
2. 生命周期自由控制：通过malloc()或calloc()分配的堆空间，在不再使用后，需要程序员手动调用free()函数进行释放。
堆的使用场景：1. 动态数组：当程序无法预先知道数组大小时，可以使用堆来动态申请空间。
2. 链表：链表结构通常需要通过堆来进行动态内存分配。
二、栈栈是C语言中用于函数调用和局部变量存储的一块内存区域。
在函数调用过程中，栈会记录函数的调用顺序、调用参数以及局部变量等。
栈的特点：1. 后进先出：栈是一种后进先出（LIFO）的数据结构，函数调用时会依次将函数入栈，并在函数返回时依次出栈。
2. 自动管理：栈内存的分配和释放是由编译器自动完成的，程序员无需手动管理。
栈的使用场景：1. 函数调用：栈用于管理函数的调用顺序以及函数内部的局部变量。
2. 递归：递归函数的调用过程涉及到栈的递归压栈和递归出栈。
三、静态存储区静态存储区是C语言中使用static关键字声明的变量所存储的内存区域。
在程序运行期间，静态变量在内存中的位置始终不变，且仅在程序结束时才会释放。
静态存储区的特点：1. 生命周期长：静态变量在程序运行期间都存在，不依赖于函数的调用和返回。
2. 全局可访问：静态变量可以在整个程序中被访问，不受函数作用域的限制。
静态存储区的使用场景：1. 全局变量：使用static关键字声明的全局变量存储在静态存储区中，可以在整个程序中被访问。
2. 共享数据：多个函数之间需要共享的数据可以使用静态变量来实现。
c语言注意事项
c语言注意事项C语言是一种广泛应用于系统编程和嵌入式开发领域的计算机编程语言，其具有高效、灵活等特点。
然而，在编写C语言程序时，也需要注意一些细节和注意事项，以确保程序的安全性和可靠性。
以下是一些需要注意的事项：1. 变量声明和初始化在使用变量之前，要先声明它们的类型，并进行初始化。
未初始化的变量将具有随机的值，可能导致程序错误。
2. 内存管理在C语言中，手动管理内存是很重要的。
在使用动态分配的内存（例如使用malloc函数）之后，必须使用free函数来释放内存。
否则，会导致内存泄漏。
3. 数组越界在使用数组时，要确保不超过数组的边界。
访问超出数组范围的元素可能会导致内存错误，从而导致程序崩溃或产生未定义的行为。
4. 指针使用指针是C语言中的重要概念，但同时也容易引发错误。
必须确保指针在使用前被初始化，并且在使用指针之前，要进行有效性检查，以避免空指针引起的错误。
5. 字符串处理在C语言中，字符串是以字符数组的形式表示的。
在处理字符串时，要注意字符串的长度，并确保在使用字符串函数（如strcpy、strcat等）时不会导致缓冲区溢出。
6. 错误处理在编写C语言程序时，应该预料到可能出现的错误，并使用适当的错误处理机制来应对。
可以使用错误代码、异常处理等方式来处理错误情况，以确保程序的可靠性。
7. 注释和代码风格为了增强代码的可读性和可维护性，应该为代码添加适当的注释，解释代码的功能和思路。
同时，采用一致的代码风格和命名规范，并保持良好的缩进和清晰的结构。
8. 循环和递归在使用循环和递归时，要确保终止条件的正确性，并避免进入无限循环状态。
同时，要注意循环和递归的性能问题，避免过多的迭代或递归调用，导致程序效率低下。
9. 数值溢出和类型转换在进行数值计算时，要注意数据类型的选择和类型转换的正确性。
过大或过小的数值可能导致溢出，从而导致错误的结果。
10. 并发和线程安全在多线程环境下，要考虑并发访问共享资源的安全性问题。
C语言技术中需要注意的常见陷阱
C语言技术中需要注意的常见陷阱C语言作为一门广泛应用于系统开发和嵌入式领域的编程语言，其灵活性和高效性备受开发者青睐。
然而，正是由于其底层性质和灵活性，C语言也存在一些常见的陷阱，容易导致程序错误和安全问题。
本文将探讨一些常见的C语言陷阱，并提供相应的解决方案。
1. 内存管理错误C语言中的内存管理是开发者必须重视的问题之一。
常见的内存管理错误包括内存泄漏、野指针和缓冲区溢出。
内存泄漏指的是程序在分配内存后未及时释放，导致内存资源浪费。
野指针则是指指向已经释放或未分配的内存地址，使用野指针可能导致程序崩溃或产生不可预料的行为。
缓冲区溢出是指向数组或缓冲区写入超过其容量的数据，可能导致数据覆盖和安全漏洞。
解决这些问题的方法包括合理使用malloc和free函数进行内存分配和释放、及时检查指针的有效性，以及使用安全的字符串处理函数（如strcpy_s和strcat_s）来避免缓冲区溢出。
2. 整数溢出C语言中整数溢出是一个常见的错误，特别是在进行数值计算时。
当一个整数超过其数据类型所能表示的范围时，会发生溢出，导致结果错误。
例如，当一个无符号整数变量达到最大值后再加1，结果会变为0，而不是正确的数值。
解决整数溢出的方法包括使用适当的数据类型来存储数值，进行溢出检查，以及使用安全的数值计算函数（如加法函数add_with_overflow）来避免溢出问题。
3. 字符串处理C语言中的字符串处理需要格外小心，容易导致缓冲区溢出和安全漏洞。
常见的问题包括未对字符串长度进行检查，使用不安全的字符串处理函数（如strcpy和strcat），以及未对输入进行验证和过滤。
解决这些问题的方法包括使用安全的字符串处理函数（如strncpy和strncat），对字符串长度进行检查，以及对用户输入进行验证和过滤，以防止恶意输入导致的安全问题。
4. 多线程并发在多线程并发编程中，C语言需要特别注意线程同步和竞态条件问题。
竞态条件指的是多个线程同时访问共享资源，导致结果不确定或错误。
malloc函数的用法和功能
malloc函数的用法和功能malloc函数是C语言中的一个标准库函数，用于动态分配内存空间。
它的功能是在堆内存中分配一块指定大小的内存空间，并返回其首地址。
malloc函数的使用格式为：```void *malloc(size_t size);```其中，`size`参数指定要分配的内存空间的大小，单位为字节。
malloc函数返回的是一个指向分配内存空间起始地址的指针。
如果分配失败，则返回NULL指针。
malloc函数的主要功能包括以下几个方面：1. 动态内存分配：malloc函数通过在堆内存中分配一块指定大小的内存空间来满足程序的动态内存需求。
相比于静态分配的数据，动态分配的内存空间可以根据程序实际需求的变化进行灵活的调整。
2. 内存管理：malloc函数将分配的内存空间管理在堆区中。
程序员可以通过malloc函数分配的指针来操作该内存空间，包括读取、写入、释放等操作。
通过有效地管理分配的内存空间，可以提高程序的运行效率和资源利用率。
3. 内存分配的灵活性：malloc函数可根据不同情况动态分配不同大小的内存空间。
根据实际需求，可以动态调整内存空间的大小和数量，以满足程序的需求。
这种灵活性使得程序能够根据实际情况分配内存，提高内存利用率。
4. 内存分配的可移植性：malloc函数是标准库函数，可在不同的平台上使用。
这使得程序具有较好的可移植性，能够在不同的操作系统和编译器上运行，提高了程序的通用性。
使用malloc函数时需要注意以下几点：1. 分配的内存空间需要手动释放。
程序员在使用malloc分配内存后，需要在不需要该内存空间时手动调用free函数进行释放，以避免内存泄漏。
2. 分配的内存空间不会自动初始化。
malloc函数仅分配内存空间，但不会对其进行初始化。
如果需要初始化内存空间，程序员需要手动进行初始化操作。
3. 分配的内存空间应合理使用。
程序员需要合理估计所需的内存空间大小，避免分配过多或过少的内存空间，以免造成资源的浪费或运行时的错误。
C语言技术高级教程
C语言技术高级教程C语言是一门广泛应用于计算机编程领域的高级编程语言，它具有高效、灵活和可移植等特点，因此在软件开发中得到广泛的应用。
本文将介绍C语言的一些高级技术，帮助读者更好地理解和应用这门语言。
一、指针与内存管理指针是C语言中一个非常重要的概念，它可以用来直接访问和操作内存中的数据。
通过指针，我们可以实现高效的内存管理和数据结构操作。
在使用指针时，需要注意指针的声明、初始化和解引用等操作，以及指针的空指针和野指针等问题。
内存管理是C语言中一个关键的技术，合理地管理内存可以提高程序的性能和可靠性。
在C语言中，我们可以使用malloc和free等函数来动态分配和释放内存。
同时，还可以使用内存池和内存回收等技术来优化内存管理，减少内存碎片和提高内存利用率。
二、文件操作和IO流在C语言中，文件操作是一个常见的需求。
通过文件操作，我们可以读取和写入文件中的数据，实现数据的持久化存储和交换。
在C语言中，可以使用fopen、fread、fwrite等函数来打开、读取和写入文件。
同时，还可以使用feof、fseek等函数来进行文件的定位和判断。
IO流是C语言中一个重要的概念，它可以实现输入和输出的流式处理。
在C语言中，可以使用标准库中的stdio.h头文件来实现IO流的操作。
通过使用printf和scanf等函数，我们可以实现数据的格式化输出和输入。
同时，还可以使用文件指针和流重定向等技术来实现对文件的输入和输出。
三、多线程和并发编程多线程和并发编程是现代计算机领域中一个热门的话题。
在C语言中，可以使用pthread库来实现多线程的创建和管理。
通过使用线程，我们可以实现任务的并行执行，提高程序的性能和响应能力。
同时，还可以使用互斥锁和条件变量等技术来实现线程之间的同步和通信。
并发编程是一种复杂的编程模型，它需要考虑多个任务之间的交互和竞争。
在C语言中，可以使用信号量和消息队列等技术来实现并发编程。
通过使用信号量，我们可以实现对共享资源的互斥访问。
c语言申请和释放内存的语句 -回复
c语言申请和释放内存的语句-回复C语言申请和释放内存的语句在C语言中，内存的申请和释放是程序开发中非常重要的一部分。
这是因为在程序运行过程中，经常需要临时存储和处理数据。
当然，内存的申请和释放如果不妥善处理，将会导致内存泄漏或者内存溢出等问题，进而影响程序的正确性和性能。
因此，在C语言中，正确地使用内存管理函数是非常重要的一项技能。
内存申请的函数是malloc，而内存释放的函数是free。
在使用这两个函数之前，我们需要了解一些基本的概念和使用方式。
首先是malloc函数，它的原型如下：void *malloc(size_t size);可以看到，malloc函数的返回值是void类型的指针，这意味着它可以分配任意类型的内存空间。
它接受一个参数size，表示要申请的内存大小，单位是字节。
在函数执行成功时，它会返回一个指向申请到的内存空间的指针；如果申请失败，它会返回NULL。
下面是malloc函数的一个简单示例：int *p;p = (int*)malloc(sizeof(int));这段代码中，我们申请了一个int类型大小的内存空间，并将指向该内存空间的指针存储在p变量中。
需要注意的是，malloc函数返回的是void 指针，所以必须进行强制类型转换，将其转换为指向int类型的指针。
接下来是free函数，它的原型如下：void free(void *ptr);free函数只有一个参数ptr，它表示要释放的内存空间的指针。
调用free 函数后，该内存空间就会被释放，并可以被系统重新分配给其他对象使用。
需要注意的是，释放一个已经被释放的内存空间是非法的，并且会导致未定义的行为。
另外，在调用free函数之前，我们应该确保ptr变量不为NULL，否则可能会导致程序崩溃。
下面是free函数的一个简单示例：int *p;p = (int*)malloc(sizeof(int));使用p指针进行一些操作free(p);这段代码中，我们先是申请了一个int类型大小的内存空间，并将指向该内存空间的指针存储在p变量中。
c语言常见的问题和疑问
c语言常见的问题和疑问以下是一些在C语言编程中常见的问题和疑问：1.编译错误问题：编译时出现错误，提示语法错误、类型不匹配等。
解决方法：仔细检查代码中的语法错误，确认所有的语句、函数和数据类型都正确无误。
2.内存管理问题：如何分配和释放内存？解决方法：使用malloc()函数分配内存，使用free()函数释放内存。
3.指针操作问题：如何使用指针？如何通过指针访问变量？解决方法：理解指针的概念和用法，熟练掌握指针的运算和访问。
4.数组越界问题：如何避免数组越界？解决方法：确认数组的索引在有效范围内，并使用循环语句时检查边界条件。
5.逻辑错误问题：程序逻辑出现错误，无法达到预期结果。
解决方法：仔细检查程序中的逻辑错误，可以通过调试工具或打印输出调试。
6.变量作用域问题：变量作用域不明确，导致程序出现错误。
解决方法：理解变量的作用域和生命周期，避免在不同作用域中使用同名变量。
7.线程安全问题：多线程竞争导致数据不一致或程序崩溃。
解决方法：使用同步机制如互斥锁、信号量等来保证线程安全。
8.输入输出问题：输入输出不匹配，导致程序异常。
解决方法：理解输入输出的原理和格式，正确处理输入输出的数据。
9.格式化输出问题：输出的格式不正确，影响阅读和理解。
解决方法：使用printf()函数进行格式化输出，掌握各种格式标识符的使用方法。
10.内存泄漏问题：程序运行过程中出现内存泄漏，导致内存消耗过大。
解决方法：使用内存管理函数时注意释放内存，避免出现内存泄漏。
11.数据类型转换问题：数据类型不匹配，导致计算结果不正确。
解决方法：理解数据类型的转换规则和方法，掌握强制类型转换和自动类型转换的使用方法。
12.宏定义使用问题：宏定义使用不当，导致程序出现异常。
解决方法：掌握宏定义的基本语法和使用方法，避免出现宏定义冲突或错误。
13.条件语句使用问题：条件语句使用不当，导致程序逻辑出现错误。
解决方法：理解条件语句的语法和执行流程，掌握if、switch等条件语句的使用方法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
踏入C 中的雷区——C 内存管理详解伟大的Bill Gates 曾经失言：640K ought to be enough for everybody — Bill Gates 1981程序员们经常编写内存管理程序，往往提心吊胆。
如果不想触雷，唯一的解决办法就是发现所有潜伏的地雷并且排除它们，躲是躲不了的。
本文的内容比一般教科书的要深入得多，读者需细心阅读，做到真正地通晓内存管理。
1、内存分配方式内存分配方式有三种：（1）从静态存储区域分配。
内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。
例如全局变量，static变量。
（2）在栈上创建。
在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。
栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
（3）从堆上分配，亦称动态内存分配。
程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。
动态内存的生存期由我们决定，使用非常灵活，但问题也最多。
2、常见的内存错误及其对策发生内存错误是件非常麻烦的事情。
编译器不能自动发现这些错误，通常是在程序运行时才能捕捉到。
而这些错误大多没有明显的症状，时隐时现，增加了改错的难度。
有时用户怒气冲冲地把你找来，程序却没有发生任何问题，你一走，错误又发作了。
常见的内存错误及其对策如下：* 内存分配未成功，却使用了它。
编程新手常犯这种错误，因为他们没有意识到内存分配会不成功。
常用解决办法是，在使用内存之前检查指针是否为NULL。
如果指针p是函数的参数，那么在函数的入口处用assert(p!=NULL)进行检查。
如果是用malloc或new来申请内存，应该用if(p==NULL) 或if(p!=NULL)进行防错处理。
* 内存分配虽然成功，但是尚未初始化就引用它。
犯这种错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值全为零，导致引用初值错误（例如数组）。
内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候为零值，我们宁可信其无不可信其有。
所以无论用何种方式创建数组，都别忘了赋初值，即便是赋零值也不可省略，不要嫌麻烦。
* 内存分配成功并且已经初始化，但操作越过了内存的边界。
例如在使用数组时经常发生下标“多1”或者“少1”的操作。
特别是在for循环语句中，循环次数很容易搞错，导致数组操作越界。
* 忘记了释放内存，造成内存泄露。
含有这种错误的函数每被调用一次就丢失一块内存。
刚开始时系统的内存充足，你看不到错误。
终有一次程序突然死掉，系统出现提示：内存耗尽。
动态内存的申请与释放必须配对，程序中malloc与free的使用次数一定要相同，否则肯定有错误（new/delete同理）。
* 释放了内存却继续使用它。
有三种情况：（1）程序中的对象调用关系过于复杂，实在难以搞清楚某个对象究竟是否已经释放了内存，此时应该重新设计数据结构，从根本上解决对象管理的混乱局面。
（2）函数的return语句写错了，注意不要返回指向“栈内存”的“指针”或者“引用”，因为该内存在函数体结束时被自动销毁。
（3）使用free或delete释放了内存后，没有将指针设置为NULL。
导致产生“野指针”。
【规则1】用malloc或new申请内存之后，应该立即检查指针值是否为NULL。
防止使用指针值为NULL的内存。
【规则2】不要忘记为数组和动态内存赋初值。
防止将未被初始化的内存作为右值使用。
【规则3】避免数组或指针的下标越界，特别要当心发生“多1”或者“少1”操作。
【规则4】动态内存的申请与释放必须配对，防止内存泄漏。
【规则5】用free或delete释放了内存之后，立即将指针设置为NULL，防止产生“野指针”。
3、指针与数组的对比C /C程序中，指针和数组在不少地方可以相互替换着用，让人产生一种错觉，以为两者是等价的。
数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。
数组名对应着（而不是指向）一块内存，其地址与容量在生命期内保持不变，只有数组的内容可以改变。
指针可以随时指向任意类型的内存块，它的特征是“可变”，所以我们常用指针来操作动态内存。
指针远比数组灵活，但也更危险。
下面以字符串为例比较指针与数组的特性。
3.1 修改内容示例3-1中，字符数组a的容量是6个字符，其内容为hello。
a的内容可以改变，如a[0]= ‘X’。
指针p指向常量字符串“world”（位于静态存储区，内容为world），常量字符串的内容是不可以被修改的。
从语法上看，编译器并不觉得语句p[0]= ‘X’有什么不妥，但是该语句企图修改常量字符串的内容而导致运行错误。
3.2 内容复制与比较不能对数组名进行直接复制与比较。
示例7-3-2中，若想把数组a的内容复制给数组b，不能用语句 b = a ，否则将产生编译错误。
应该用标准库函数strcpy进行复制。
同理，比较b和a的内容是否相同，不能用if(b==a) 来判断，应该用标准库函数strcmp进行比较。
语句p = a 并不能把a的内容复制指针p，而是把a的地址赋给了p。
要想复制a 的内容，可以先用库函数malloc为p申请一块容量为strlen(a) 1个字符的内存，再用strcpy进行字符串复制。
同理，语句if(p==a) 比较的不是内容而是地址，应该用库函数strcmp来比较。
3.3 计算内存容量用运算符sizeof可以计算出数组的容量（字节数）。
示例7-3-3（a）中，sizeof(a)的值是12（注意别忘了’’）。
指针p指向a，但是sizeof(p)的值却是4。
这是因为sizeof(p)得到的是一个指针变量的字节数，相当于sizeof(char*)，而不是p所指的内存容量。
C /C语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。
注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。
示例7-3-3（b）中，不论数组a的容量是多少，sizeof(a)始终等于sizeof(char *)。
示例3.3（b）数组退化为指针4、指针参数是如何传递内存的？如果函数的参数是一个指针，不要指望用该指针去申请动态内存。
示例7-4-1中，Test函数的语句GetMemory(str, 200)并没有使str获得期望的内存，str依旧是NULL，为什么？示例4.1 试图用指针参数申请动态内存毛病出在函数GetMemory中。
编译器总是要为函数的每个参数制作临时副本，指针参数p的副本是 _p，编译器使 _p = p。
如果函数体内的程序修改了_p的内容，就导致参数p的内容作相应的修改。
这就是指针可以用作输出参数的原因。
在本例中，_p申请了新的内存，只是把_p所指的内存地址改变了，但是p丝毫未变。
所以函数GetMemory并不能输出任何东西。
事实上，每执行一次GetMemory就会泄露一块内存，因为没有用free释放内存。
如果非得要用指针参数去申请内存，那么应该改用“指向指针的指针”，见示例4.2。
示例4.2用指向指针的指针申请动态内存由于“指向指针的指针”这个概念不容易理解，我们可以用函数返回值来传递动态内存。
这种方法更加简单，见示例4.3。
示例4.3 用函数返回值来传递动态内存用函数返回值来传递动态内存这种方法虽然好用，但是常常有人把return语句用错了。
这里强调不要用return语句返回指向“栈内存”的指针，因为该内存在函数结束时自动消亡，见示例4.4。
示例4.4 return语句返回指向“栈内存”的指针用调试器逐步跟踪Test4，发现执行str = GetString语句后str不再是NULL指针，但是str的内容不是“hello world”而是垃圾。
如果把示例4.4改写成示例4.5，会怎么样？示例4.5 return语句返回常量字符串函数Test5运行虽然不会出错，但是函数GetString2的设计概念却是错误的。
因为GetString2内的“hello world”是常量字符串，位于静态存储区，它在程序生命期内恒定不变。
无论什么时候调用GetString2，它返回的始终是同一个“只读”的内存块。
5、杜绝“野指针”“野指针”不是NULL指针，是指向“垃圾”内存的指针。
人们一般不会错用NULL 指针，因为用if语句很容易判断。
但是“野指针”是很危险的，if语句对它不起作用。
“野指针”的成因主要有两种：（1）指针变量没有被初始化。
任何指针变量刚被创建时不会自动成为NULL指针，它的缺省值是随机的，它会乱指一气。
所以，指针变量在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。
例如（2）指针p被free或者delete之后，没有置为NULL，让人误以为p是个合法的指针。
（3）指针操作超越了变量的作用范围。
这种情况让人防不胜防，示例程序如下：函数Test在执行语句p->Func()时，对象a已经消失，而p是指向a的，所以p就成了“野指针”。
但奇怪的是我运行这个程序时居然没有出错，这可能与编译器有关。
6、有了malloc/free为什么还要new/delete？malloc与free是C /C语言的标准库函数，new/delete是C 的运算符。
它们都可用于申请动态内存和释放内存。
对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。
对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。
由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。
因此C 语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。
注意new/delete不是库函数。
我们先看一看malloc/free和new/delete如何实现对象的动态内存管理，见示例6。
示例6 用malloc/free和new/delete如何实现对象的动态内存管理类Obj的函数Initialize模拟了构造函数的功能，函数Destroy模拟了析构函数的功能。
函数UseMallocFree中，由于malloc/free不能执行构造函数与析构函数，必须调用成员函数Initialize和Destroy来完成初始化与清除工作。
函数UseNewDelete则简单得多。
所以我们不要企图用malloc/free来完成动态对象的内存管理，应该用new/delete。
由于内部数据类型的“对象”没有构造与析构的过程，对它们而言malloc/free和new/delete是等价的。
既然new/delete的功能完全覆盖了malloc/free，为什么C 不把malloc/free淘汰出局呢？这是因为C 程序经常要调用C函数，而C程序只能用malloc/free管理动态内存。