使用strcpy和memcpy的区别和sizeof()和strlen的区别

在使用new申请的内存前,一定要判断申请的内存是否够用!!!

在使用new申请的内存前,一定要判断申请的内存是否够用!!!

在使用new申请的内存前,一定要判断申请的内存是否够用!!!

 

在使用strcpy(char* dest, const char *src)和memcpy(void* dst,const void* src,size_t count)时,

一定要判断str1申请的内存dest是否大于src的长度

dst 的内存是否大于cout。

strcpy和memcpy的区别

  • 复制的内容不同。strcpy只能复制字符串,而memcpy可以复制任意内容,例如字符数组、整型、结构体、类等。
  • 复制的方法不同。strcpy不需要指定长度,它遇到被复制字符的串结束符"\0"才结束,所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。
  • 用途不同。通常在复制字符串时用strcpy,而需要复制其他类型数据时则一般用memcpy

strcpy和memcpy的使用方法

strcpy(char* strDest,const char* strSrc);

memcpy(void *pvTo, const void *pvFrom, size_t size)

strlen()和sizeof()的区别

  • sizeof操作符的结果类型是size_t,它在头文件中typedef为unsigned int类型。该类型保证能容纳实现所建立的最大对象的字节大小。
  • sizeof是算符,strlen是函数。
  • sizeof可以用类型做参数,strlen只能用char*做参数,且必须是以''\0''结尾的。sizeof还可以用函数做参数(例如sizeof(f())=2)。
  • 数组做sizeof的参数不退化,传递给strlen就退化为指针了。
  • 大部分编译程序 在编译的时候就把sizeof计算过了 是类型或是变量的长度这就是sizeof(x)可以用来定义数组维数的原因。

例如:

char str[20]="0123456789";

int a=strlen(str); //a=10;

int b=sizeof(str); //而b=20;

  • strlen的结果要在运行的时候才能计算出来,用来计算字符串的长度,不是类型占内存的大小。

  • sizeof后如果是类型必须加括弧,如果是变量名可以不加括弧。这是因为sizeof是个操作符不是个函数。

  • 当适用了于一个结构类型时或变量,sizeof返回实际的大小,当适用一静态地空间数组,sizeof归还全部数组的尺寸。
    sizeof 操作符不能返回被动态分配了的数组或外部的数组的尺寸。

  • 数组作为参数传给函数时传的是指针而不是数组,传递的是数组的首地址,
    如:fun(char [8])=2

案例:

char* ss = "0123456789";
sizeof(ss)结果是4。 ss是指向字符串常量的字符指针,sizeof获得的是一个指针的之所占的空间,所以是4。
sizeof(*ss)结果1.*ss是第一个字符 其实就是获得了字符串的第一位'0'所占的内存空间,是char类型的,占了1位。
strlen(ss)结果则是10。 如果要获得这个字符串的长度,则一定要使用 strlen

 

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
哈夫曼编码和解码是一种常用的数据压缩算法,它可以将原始数据编码为更短的二进制码,从而实现数据压缩。 下面是一个简单的哈夫曼编码和解码的C代码示例: ```c #include <stdio.h> #include <stdlib.h> #include <string.h> // 定义哈夫曼树节点结构体 typedef struct huffman_node { int weight; // 权重 char symbol; // 符号 struct huffman_node *left; // 左子节点 struct huffman_node *right; // 右子节点 } huffman_node_t; // 定义哈夫曼编码结构体 typedef struct huffman_code { char symbol; // 符号 char *code; // 编码 } huffman_code_t; // 声明函数 huffman_node_t *create_huffman_tree(int *weights, char *symbols, int n); void destroy_huffman_tree(huffman_node_t *root); void encode_huffman(huffman_node_t *root, char *code, huffman_code_t *huffman_codes); void decode_huffman(huffman_node_t *root, char *code); int main(int argc, char **argv) { // 定义原始数据 char *data = "hello world"; int n = strlen(data); // 计算每个字符出现的次数 int weights[256] = {0}; for (int i = 0; i < n; i++) { weights[(int)data[i]]++; } // 创建哈夫曼树 char symbols[256]; for (int i = 0; i < 256; i++) { symbols[i] = (char)i; } huffman_node_t *root = create_huffman_tree(weights, symbols, 256); // 生成哈夫曼编码 huffman_code_t huffman_codes[256]; encode_huffman(root, "", huffman_codes); // 输出哈夫曼编码 for (int i = 0; i < 256; i++) { if (huffman_codes[i].code != NULL) { printf("%c: %s\n", huffman_codes[i].symbol, huffman_codes[i].code); } } // 压缩数据 char *compressed_data = (char *)malloc(n * 8 + 1); char *p = compressed_data; for (int i = 0; i < n; i++) { huffman_code_t huffman_code = huffman_codes[(int)data[i]]; memcpy(p, huffman_code.code, strlen(huffman_code.code)); p += strlen(huffman_code.code); } *p = '\0'; // 输出压缩后的数据 printf("compressed data: %s\n", compressed_data); // 解压数据 decode_huffman(root, compressed_data); // 释放内存 free(compressed_data); destroy_huffman_tree(root); return 0; } // 创建哈夫曼树 huffman_node_t *create_huffman_tree(int *weights, char *symbols, int n) { // 创建叶子节点 huffman_node_t *nodes[n]; for (int i = 0; i < n; i++) { nodes[i] = (huffman_node_t *)malloc(sizeof(huffman_node_t)); nodes[i]->weight = weights[(int)symbols[i]]; nodes[i]->symbol = symbols[i]; nodes[i]->left = NULL; nodes[i]->right = NULL; } // 创建哈夫曼树 while (n > 1) { // 找到最小的两个节点 int min1 = -1, min2 = -1; for (int i = 0; i < n; i++) { if (nodes[i] != NULL) { if (min1 == -1 || nodes[i]->weight < nodes[min1]->weight) { min2 = min1; min1 = i; } else if (min2 == -1 || nodes[i]->weight < nodes[min2]->weight) { min2 = i; } } } // 合并节点 huffman_node_t *new_node = (huffman_node_t *)malloc(sizeof(huffman_node_t)); new_node->weight = nodes[min1]->weight + nodes[min2]->weight; new_node->left = nodes[min1]; new_node->right = nodes[min2]; nodes[min1] = new_node; nodes[min2] = NULL; n--; } return nodes[min1]; } // 销毁哈夫曼树 void destroy_huffman_tree(huffman_node_t *root) { if (root != NULL) { destroy_huffman_tree(root->left); destroy_huffman_tree(root->right); free(root); } } // 生成哈夫曼编码 void encode_huffman(huffman_node_t *root, char *code, huffman_code_t *huffman_codes) { if (root->left == NULL && root->right == NULL) { int i = (int)root->symbol; huffman_codes[i].symbol = root->symbol; huffman_codes[i].code = (char *)malloc(strlen(code) + 1); strcpy(huffman_codes[i].code, code); } else { char left_code[strlen(code) + 2]; char right_code[strlen(code) + 2]; sprintf(left_code, "%s%s", code, "0"); sprintf(right_code, "%s%s", code, "1"); encode_huffman(root->left, left_code, huffman_codes); encode_huffman(root->right, right_code, huffman_codes); } } // 解码哈夫曼编码 void decode_huffman(huffman_node_t *root, char *code) { huffman_node_t *p = root; for (int i = 0; code[i] != '\0'; i++) { if (code[i] == '0') { p = p->left; } else { p = p->right; } if (p->left == NULL && p->right == NULL) { printf("%c", p->symbol); p = root; } } printf("\n"); } ``` 这段代码实现了哈夫曼编码和解码的功能,其中`create_huffman_tree`函数用于创建哈夫曼树,`encode_huffman`函数用于生成哈夫曼编码,`decode_huffman`函数用于解码哈夫曼编码。你可以根据自己的需求进行修改和优化。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值