memset方法
memset 方法是一个在C和C++中广泛使用的库函数，用于将某一块内存中的全部字节设置为指定的值。这个函数通常用于内存空间的初始化或清零操作。以下是关于 memset 方法的详细解释：
函数原型
在C语言中，memset 函数的原型定义在 <string.h> 头文件中；在C++中，则定义在 或 <string.h>（这取决于编译器和平台）中。函数原型如下：
c
void *memset(void *s, int c, size_t n);
参数说明
s：指向要填充的内存块的指针。
c：要被设置的值。需要注意的是，虽然参数类型为 int，但 memset 函数实际上只使用 c 的低8位（即一个字节）。
n：要被设置该值的字节数。
返回值
memset 函数返回一个指向 s 的指针，即原始内存块的指针。
使用方法
初始化数组：可以将数组的所有元素初始化为同一个值。例如，将一个字符数组的所有元素初始化为0或某个字符。
c
char str[100];
memset(str, 0, sizeof(str)); // 将str数组的所有元素初始化为0
char chArray[100];
memset(chArray, 'A', sizeof(chArray)); // 将chArray数组的所有元素初始化为'A'
清空结构体：对于结构体变量，memset 可以用来将其所有成员初始化为0（或-1，但需要注意字节表示）。这对于包含指针的结构体需要谨慎使用，因为将指针成员初始化为0通常是安全的，但可能不是所有成员都适合这样做。
c
typedef struct {
char name[20];
int age;
} Person;
Person p;
memset(&p, 0, sizeof(Person)); // 将p的所有成员初始化为0
注意事项：
memset 是按字节设置内存的，因此对于非字符类型（如 int、float 等）的数组，如果设置的值不是0或-1（在二进制表示中所有字节都相同），则可能不会得到预期的结果。
当使用 memset 对结构体或数组进行初始化时，需要确保不会覆盖任何不应该被修改的内存区域（例如，结构体中的指针成员可能不应该被设置为0，除非这是你的意图）。
对于动态分配的内存，使用 sizeof 运算符时需要特别小心。如果指针变量是通过 malloc、calloc 或 realloc 等函数分配的，那么 sizeof 运算符作用于该指针变量时得到的是指针本身的大小（通常是4或8字节），而不是它所指向的内存块的大小。因此，在这种情况下，应该使用在分配时记录的大小或通过其他方式计算要设置的字节数。
示例
c
#include <stdio.h>
#include <string.h>
int main() {
int array[4];
memset(array, 0, sizeof(array)); // 将array的所有元素初始化为0
for (int i = 0; i < 4; i++) {
printf("%d ", array[i]); // 输出: 0 0 0 0
}
return 0;
}
在这个示例中，memset 函数被用来将一个整型数组的所有元素初始化为0。由于整型数组的每个元素占用多个字节（通常是4字节），但 memset 是按字节设置的，因此这里使用0作为填充值是安全的，因为0的二进制表示在所有字节位置上都是0。然而，如果尝试将数组元素初始化为非0且非-1的整数值，则可能会得到意想不到的结果。
calloc
calloc 是C和C++语言中用于动态内存分配的一个函数，它可以在内存的动态存储区中分配指定数量的连续空间，并自动将分配的内存初始化为零。以下是关于 calloc 函数的详细解释：
一、函数原型
在C语言中，calloc 函数的原型定义在 <stdlib.h> 头文件中（部分旧系统可能也支持 <malloc.h>，但 <stdlib.h> 是更标准的选择）。其原型如下：
c
void *calloc(size_t num, size_t size);
二、功能描述
calloc 函数用于在内存的动态存储区中分配 num 个长度为 size 的连续空间。分配的内存块中的每个字节都会被初始化为0。如果分配成功，函数返回一个指向分配的内存块的起始地址的指针；如果分配失败（例如，由于内存不足），则返回NULL。
三、参数说明
num：指定要分配的元素数量。
size：指定每个元素的大小（以字节为单位）。
四、返回值
成功时，返回一个指向分配的内存块的起始地址的指针。
失败时，返回NULL。
五、与 malloc 的区别
内存初始化：calloc 分配的内存会自动初始化为零，而 malloc 分配的内存则不进行初始化，其内容是不确定的。
参数个数：calloc 需要两个参数（元素数量和每个元素的大小），而 malloc 只需要一个参数（要分配的内存块的总大小）。
效率：如果只需要分配内存而不需要初始化，malloc 通常比 calloc 更高效。
六、使用注意事项
类型转换：由于 calloc 返回的是 void* 类型的指针，如果要将它赋给特定类型的指针变量，需要进行适当的类型转换。
内存释放：使用完分配的内存后，应该使用 free 函数释放它，以避免内存泄漏。
错误检查：在调用 calloc 后，应该检查返回值是否为NULL，以判断内存分配是否成功。
七、示例代码
以下是一个使用 calloc 函数的简单示例：
c
#include <stdio.h>
#include <stdlib.h>
int main() {
int *array = (int *)calloc(10, sizeof(int)); // 分配一个包含10个整数的数组，并初始化为0
if (array == NULL) {
// 处理内存分配失败的情况
printf(“Memory allocation failed!\n”);
return 1;
}
// 使用array...
// 释放内存
free(array);
return 0;
}
在这个示例中，我们使用 calloc 函数分配了一个包含10个整数的数组，并检查了内存分配是否成功。然后，我们可以安全地使用这个数组，并在不再需要时释放它。
代码规范之错误处理
定义错误
/**
Error codes returned.
*/
typedef enum DWG_ERROR
{
DWG_NOERR = 0,
/* sorted by severity */
DWG_ERR_WRONGCRC = 1,
DWG_ERR_NOTYETSUPPORTED = 1 << 1, /* 2 */
DWG_ERR_UNHANDLEDCLASS = 1 << 2, /* 4 */
DWG_ERR_INVALIDTYPE = 1 << 3, /* 8 */
DWG_ERR_INVALIDHANDLE = 1 << 4, /* 16 */
DWG_ERR_INVALIDEED = 1 << 5, /* 32 */
DWG_ERR_VALUEOUTOFBOUNDS = 1 << 6, /* 64 */
/* -------- critical errors ------- */
DWG_ERR_CLASSESNOTFOUND = 1 << 7, /* 128 */
DWG_ERR_SECTIONNOTFOUND = 1 << 8, /* 256 */
DWG_ERR_PAGENOTFOUND = 1 << 9, /* 512 */
DWG_ERR_INTERNALERROR = 1 << 10,/* 1024 */
DWG_ERR_INVALIDDWG = 1 << 11,/* 2048 */
DWG_ERR_IOERROR = 1 << 12,/* 4096 */
DWG_ERR_OUTOFMEM = 1 << 13,/* 8192 */
} Dwg_Error;
fread
错误枚举使用
EXPORT int
dat_read_file (Bit_Chain *restrict dat, FILE *restrict fp,
const char *restrict filename)
{
size_t size;
if (!dat->size && fp)
{
struct_stat_t attrib;
int fd = fileno (fp);
if (fd >= 0 && !fstat (fd, &attrib))
dat->size = attrib.st_size;
}
dat->chain = (unsigned char *)calloc (1, dat->size + 1);
if (!dat->chain)
{
loglevel = dat->opts & DWG_OPTS_LOGLEVEL;
LOG_ERROR ("Not enough memory.\n")
fclose (fp);
dat->fh = NULL;
return DWG_ERR_OUTOFMEM;
}
size = fread (dat->chain, sizeof (char), dat->size, fp);
if (size != dat->size)
{
loglevel = dat->opts & DWG_OPTS_LOGLEVEL;
LOG_ERROR ("Could not read file (%" PRIuSIZE " out of %" PRIuSIZE
"): %s\n",
size, dat->size, filename)
fclose (fp);
free (dat->chain);
dat->chain = NULL;
dat->fh = NULL;
dat->size = 0;
return DWG_ERR_IOERROR;
}
// ensure zero-termination for strstr, strtol, ...
dat->chain[dat->size] = '\0';
return 0;
}
c++ std::vector 转化double[]或double *
在C++中，将std::vector转换为double[]（即C风格的数组）并不是直接支持的，因为std::vector是动态数组，而C风格的数组在大小上是固定的，并且它们的生命周期通常与它们被声明的块的生命周期相同。然而，你可以通过几种方式来实现类似的效果。
方法1：使用vector的data()成员函数
如果你的目标仅仅是访问vector内部的数据（例如，将其传递给需要double参数的函数），你可以直接使用std::vector::data()成员函数。这个函数返回一个指向vector内部数据的指针（double），但请注意，这个指针仅在vector的生命周期内有效。
cpp
#include <vector>
#include <iostream>
void processArray(double* array, size_t size) {
for (size_t i = 0; i < size; ++i) {
std::cout << array[i] << " ";
}
std::cout << std::endl;
}
int main() {
std::vector<double> vec = {1.0, 2.0, 3.0, 4.0, 5.0};
processArray(vec.data(), vec.size());
return 0;
}
方法2：复制数据到C风格的数组中
如果你确实需要一个C风格的数组，并且想要控制其生命周期，你需要手动复制vector中的数据到一个新的数组中。
cpp
#include <vector>
#include <iostream>
void processArray(double* array, size_t size) {
// 使用数组...
for (size_t i = 0; i < size; ++i) {
std::cout << array[i] << " ";
}
std::cout << std::endl;
// 记得在适当的时候释放数组（如果它是动态分配的）
// delete[] array; // 注意：在这个例子中，我们不应该这样做，因为array是指向栈内存的指针
}
int main() {
std::vector<double> vec = {1.0, 2.0, 3.0, 4.0, 5.0};
// 为C风格的数组分配内存（注意：这里我们直接在栈上分配，因此不需要delete）
double array[vec.size()];
// 复制数据
for (size_t i = 0; i < vec.size(); ++i) {
array[i] = vec[i];
}
// 使用数组
processArray(array, vec.size());
// 注意：在这个例子中，array是一个栈分配的数组，不需要手动释放
return 0;
}
注意：在上面的第二个例子中，为了简化说明，我在栈上直接分配了一个固定大小的数组。然而，这种方法限制了数组的大小（它必须是编译时常量），并且不适用于需要动态确定数组大小的情况。在需要动态数组大小的场景中，你可能需要使用new来动态分配内存（并记得在不再需要时使用delete[]来释放它），或者使用智能指针（如std::unique_ptr<double[]>）来管理内存。但是，在大多数情况下，如果可能的话，使用std::vector或其他现代C++容器会更安全、更方便。
702
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
