c++的memcpy_s函数用处？

最新推荐文章于 2024-05-16 14:05:08 发布
最新推荐文章于 2024-05-16 14:05:08 发布
阅读量340 收藏 1
点赞数 2
分类专栏： C++基础 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38103073/article/details/136219879
版权

memcpy_s是C++11标准中新增的函数，用于安全地复制内存块。它的作用是将源内存块中的数据复制到目标内存块中，同时可以指定要复制的字节数，以及目标内存块的大小。

与传统的memcpy函数不同的是，memcpy_s在复制数据之前会检查目标内存块的大小是否足够，以避免缓冲区溢出的问题。如果目标内存块的大小不足以容纳源内存块中的数据，则会返回一个错误码，并且不会执行复制操作。

memcpy_s的函数原型如下：

errno_t memcpy_s(void* dest, size_t destSize, const void* src, size_t count);

其中，dest表示目标内存块的指针，destSize表示目标内存块的大小，src表示源内存块的指针，count表示要复制的字节数。

memcpy_s函数返回一个errno_t类型的错误码，如果复制成功则返回0，否则返回一个非零的错误码。

帅气的任童鞋
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ 面试题 总结
09-16
C++面试题 1.是不是一个父类写了一个virtual 函数，如果子类覆盖它的函数不加virtual ,也能实现多态? virtual修饰符会被隐形继承的。 private 也被集成，只事派生类没有访问权限而已 virtual可加可不加 子类的空间里有父类的所有变量(static除外) 同一个函数只存在一个实体(inline除外) 子类覆盖它的函数不加virtual ,也能实现多态。 在子类的空间里，有父类的私有变量。私有变量不能直接访问。 -------------------------------------------------------------------------- 2.输入一个字符串，将其逆序后输出。（使用C++，不建议用伪码） #include using namespace std; void main() { char a[50];memset(a,0,sizeof(a)); int i=0,j; char t; cin.getline(a,50,'\n'); for(i=0,j=strlen(a)-1;i<strlen(a)/2;i++,j--) { t=a[i]; a[i]=a[j]; a[j]=t; } cout<<a<>str; str.replace; cout<a /= (k+m)*1*(k+m); =>a = a/9; =>a = 1; -------------------------------------------------------------------------- 5. const 符号常量； (1)const char *p (2)char const *p (3)char * const p 说明上面三
c/c++ 学习总结 初学者必备
09-16
用变量a给出下面的定义 a) 一个整型数（An integer） b) 一个指向整型数的指针（A pointer to an integer） c) 一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to an integer） d) 一个有10个整型数的数组（An array of 10 integers） e) 一个有10个指针的数组，该指针是指向一个整型数的（An array of 10 pointers to integers） f) 一个指向有10个整型数数组的指针（A pointer to an array of 10 integers） g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer） h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ） 答案是： a) int a; // An integer b) int *a; // A pointer to an integer c) int **a; // A pointer to a pointer to an integer d) int a[10]; // An array of 10 integers e) int *a[10]; // An array of 10 pointers to integers f) int (*a)[10]; // A pointer to an array of 10 integers g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer 13.下面的数据声明都代表什么? (1)float (**def)[10]; def是一个二级指针,它指向的是一个一维数组的指针,数组的元素都是float. (2)double*(*gh)[10]; gh是一个指针,它指向一个一维数组,数组元素都是double*. (3)double(*f[10])(); f是一个数组,f有10个元素,元素都是函数的指针,指向的函数类型是没有参数且返回double的函数. (4)int *((*b)[10]); 就跟int *(*b)[10]是一样的,b是一维数组的指针. (5)Long (*fun)(int); 函数指针. (6)int (*(*F)(int,int))(int); F是一个函数指针,指向的函数的类型是有两个int参数并且返回一个函数指针的函数,返回的函数指针指向有一个int参数且返回int的函数. 　所有的ASCII码都可以用“\”加数字（一般是8进制数字）来表示。而C中定义了一些字母前加"\"来表示常见的那些不能显示的ASCII字符，如\0,\t,\n等，就称为转义字符，因为后面的字符，都不是它本来的ASCII字符意思了。 　　转义字符 意义 ASCII码值(十进制) 　　\a 响铃(BEL) 007 　　\b 退格(BS) 008 　　\f 换页(FF) 012 　　\n 换行(LF) 010 　　\r 回车(CR) 013 　　\t 水平制表(HT) 009 　　\v 垂直制表(VT) 011 　　\\ 反斜杠 092 　　\? 问号字符 063 　　\' 单引号字符 039 　　\" 双引号字符 034 　　\0 空字符(NULL) 000 　　\ddd 任意字符 三位八进制 　　\xhh 任意字符 二位十六进制 　　字符型常量 　　字符型常量所表示的值是字符型变量所能包含的值。我们可以用ASCII表达式来表示一个字符型常量，或者用单引号内加反斜杠表示转义字符。 　　'A', '\x2f', '\013'; 　　其中：\x表示后面的字符是十六进制数，\0表示后面的字符是八进制数。 　　注意：在Turbo C 2.0中，字符型常量表示数的范围是-128到127，除非你把它声明为unsigned，这样就是0到255。 　　上面我们见到的\x,\n,\a等等都是叫转义字符，它告诉编译器需要用特殊的方式进行处理。下面给出所有的转义字符和所对应的意义： 　　转义字符 描述 　　\' 单引号 　　\ 双引号 　　\\ 反斜杠 　　\0 空字符 　　\ccc (最多三位)八进制数 　　\a 声音符 　　\b 退格符 　　\f 换页符 　　\n 换行符 　　\r 回车符 　　\t 水平制表符 　　\v 垂直制表符 　　\xhh(最多两位)十六进制符 下面的代码输出是什么，为什么？ 1、sizeof()和strlen()的使用? 答: 1.从功能定义上,strlen函数,用来求字符串的长度,sizeof函数是用来求指定变量或变量类型等所占用内存的 大小； 2.sizeof是运算符,而strlen是C库函数strlen只能用char*做参数,且以'\0'结尾的； 对于静态数组处理: char str[20]="0123456789"; strlen(str)=10; //表示数组中字符串的长度 sizeof(str)=20; //表示数组变量分配的长度 对于指针处理: char *str="0123456789"; strlen(str)=10; //表示字符串的长度 sizeof(str)=4; //表示指针变量的所占内存大小 sizeof(*str)=1; //表示'0'这个字符变量的所占内存大小 2、 struct 和 class的区别? 答: (1)类中的成员默认是private的,当是可以声明为public,private 和protected,结构中定义的成员默认的都是public. (2)结构中不允许定义成员函数,当是类中可以定义成员函数. (3)结构不可以存在继承关系,当是类可以存在继承关系. 3、 strcpy(), strcat(), strcmp,strlen(), strchr(), memcpy(), memcmp(), memset()的编写? 4、 内存的分配方式的分配方式有几种? 答: (1)从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量。 (2)在栈上创建。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。 (3)从堆上分配,亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存,程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定,使用非常灵活,但问题也最多。 5,、解释堆和栈的区别? 答: (1)栈区(stack):由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。 (2)堆区(heap):一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事,分配方式倒是类似于链表.(主要有:malloc/free,new/delete) 6,、枚举的用法,以及它与宏的区别? 答: 枚举(enum)作用:定义一组常量,而且这些常量组成了一个集合。当我们将emun参数传递给函数时,如果传递了一个不属于这个集合的参数,编译器报错。 区别: 枚举是类型,而宏没有类型。 枚举将检查其语法,而宏是简单的文本替换。 7、 const的用法,以及声明const变量与宏的区别? 答: const的用法有四种: a): const对象和const类型的对象; b): const指针 和 指向const的指针 及两者结合; c): const 参数修饰 和 参数返回类型的const修饰; d): const类成员 和 const 成员函数; 区别: const常量有数据类型, 而宏常量没有数据类型。编译器可以对前者进行类型安全检查,而对后者只能进行字符 替换,没有类型 安全检查。而且字符替换可能会带来料想不到的边界效应。有些集成化工具可以对const常量进行调试, 但不能对宏量进行调试。 8、函数assert的用法? 答:断言assert是仅在debug版本起作用的宏,用于检查“不应该“发生的情况。程序员可以把assert看成一个在任何系统状态下都可以安全使用的无害测试手段。 9、用预处理指令#define 声明一个常数,用以表明1年中有多少秒(忽略闰年问题)? 答: #define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL 10、 写一个"标准"宏MIN,这个宏输入两个参数并返回较小的一个? 答: #define MIN(A,B) ((A) <= (B) ? (A) : (B)) 11、嵌入式系统中经常要用到无限循环,你怎么样用C编写死循环呢? 答: 这个问题用几个解决方案。我首选的方案是: while(1) { } 一些程序员更喜欢如下方案: for(;;) { } 13、关于内存对齐的问题以及sizof()的输出? 答: 编译器自动对齐的原因:为了提高程序的性能,数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于,为了访问未对齐的内存,处理器需要作两次内存访问；然而,对齐的内存访问仅需要一次访问。 14、 static有什么用途?(请至少说明两种) 答: (1)在函数体,一个被声明为静态的变量在这一函数被调用过程中维持其值不变。 (2) 在模块内(但在函数体外),一个被声明为静态的变量可以被模块内所用函数访问,但不能被模块外其它函数访问。它是一个本地的全局变量。 (3) 在模块内,一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是,这个函数被限制在声明它的模块的本地范围内使用。 15、引用与指针有什么区别? 答: (1) 引用必须被初始化,指针不必。 (2) 引用初始化以后不能被改变,指针可以改变所指的对象。 (3) 不存在指向空值的引用,但是存在指向空值的指针。 16、什么是平衡二叉树? 答: 左右子树都是平衡二叉树 且左右子树的深度差值的绝对值不大于1。 17、堆栈溢出一般是由什么原因导致的? 答: 没有回收垃圾资源。 18、什么是预编译?何时需要预编译? 答: (1)总是使用不经常改动的大型代码体。 (2)程序由多个模块组成,所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下,可以将所有包含文件预编译为一个预编译头。 19、队列和栈有什么区别? 答: 队列先进先出；栈后进先出。 20、数组和链表的区别? 答: 数组:数据顺序存储,固定大小； 链表:数据可以随机存储,大小可动态改变； 21、为什么数组名作为参数,会改变数组的内容,而其它类型如int却不会改变变量的值? 答: 当数组名作为参数时,传递的实际上是地址。而其他类型如int作为参数时,由于函数参数值实质上是实参的一份拷贝,被调函数内部对形参的改变并不影响实参的值。 22、数据结构和算法: A:查找: (1)二分法查找; B:写出下列算法的时间复杂度和实现排序: (1)冒泡排序； (2)选择排序； (3)插入排序； (4)快速排序； (5)堆排序； (6)归并排序； 23、编写gbk_strlen函数,计算含有汉字的字符串的长度,汉字作为一个字符处理；已知:汉字编码为双字节,其中 参数里涉及指针，就要考虑该指针是不是一个需要修改的量，如果是，则参数应采用指向指针的指针。 （C语言里参数传递都是传值，是一个拷贝，修改指针，只是改变了拷贝的指向，原指针指向并没有改变，而修改指针的内容则是可以的。）如果函数的参数是一个指针，不要指望用该指针去申请动态内存。（即上面所说的修改该指针） 编译器总是要为函数的每个参数制作临时副本，指针参数p的副本是 _p,指针参数也不例外。 如果非得要用指针参数去申请内存，那么应该改用“指向指针的指针”，由于“指向指针的指针”这个概念不容易理解，我们也可以用函数返回值来传递动态内存。 常常有人把return语句用错了。这里强调不要用return语句返回指向“栈内存”的指针，因为该内存在函数结束时自动消亡。 c语言里，利用函数的返回值来表明它是否执行成功的做法最常见。 2.如果要在单链表中删除或插入一个元素，就必须知道指向删除点或插入点前面那个元素的指针才行。 数组具有随机存取性（可以立即存取任一元素） char *str = "the word" 常量字符串，静态存储区，具有程序生命期。 char *str = (char *)malloc(....); 堆上分配，手动释放，否则内存泄漏。 char str[] = "the word" 栈上分配，函数生命期。 4. '\0'不是指ASCII码值，它是字符，它的ASCII码值是0，也就是ASCII码表的第一个字符。'\0'并非是空格，空格的ASCII码值是32，只不过是输出类似于空格而已。 5. 在32位程序里，所有类型的指针的值都是一个32位整数，因为32位程序里内存地址全都是32位长，指针本身占据了4个字节的长度，即用一个字的空间保存一个地址。地址是按字节表示的，一个字节一个地址。地址＋1，移动一个字节。 6.从语法上看，你只须把指针声明语句中的指针名字和名字左边的指针声明符*去掉，剩下的就是指针所指向的类型。 *p的结果是p所指向的东西 &a的运算结果是一个指针,指针所指向的类型是a的类型，指针所指向的地址嘛，那就是a的地址。 7. 声明了一个数组TYPE array[n]，则数组名称array就有了两重含义：第一，它代表整个数组，它的类型是TYPE[n]；第二 ，它是一个指针，该指针的类型是TYPE*,该指针指向的内存区就是数组第0号单元，该指针自己占有单独的内存区. 在表达式sizeof(array)中，数组名array代表数组本身，故这时sizeof函数测出的是整个数组的大小。 sizeof(array+n)测出的是指针类型的大小。 char类型的长度是一个字节，int类型的长度是4个字节，即一个字。 sizeof()得到的值是以字节为单位，所以sizeof(int) = 4 8. char* 相当于string ，char* arr[10]即字符串数组
最新名企标准通用C++面试题，
05-08
C++面试题 参考：http://blog.csdn.net/Ghost90/archive/2009/04/22/4099672.aspx 整理：松鼠 时间：2009-5-8 1、const 有什么用途？（请至少说明两种） 答： （1）可以定义 const 常量 （2）const可以修饰函数的参数、返回值，甚至函数的定义体。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。 2、在C++ 程序中调用被 C编译器编译后的函数，为什么要加 extern “C”？ 答：C++语言支持函数重载，C语言不支持函数重载。函数被C++编译后在库中的名字与C语言的不同。假设某个函数的原型为： void foo(int x, int y); 该函数被C编译器编译后在库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。 C++提供了C连接交换指定符号extern“C”来解决名字匹配问题。 3、请简述以下两个for循环的优缺点（5分） for (i=0; i<N; i++) { if (condition) DoSomething(); else DoOtherthing(); } if (condition) { for (i=0; i<N; i++) DoSomething(); } else { for (i=0; i<N; i++) DoOtherthing(); } 优点：程序简洁 缺点：多执行了N-1次逻辑判断，并且打断了循环“流水线”作业，使得编译器不能对循环进行优化处理，降低了效率。 优点：循环的效率高 缺点：程序不简洁 4、有关内存的思考题 void GetMemory(char *p) { p = (char *)malloc(100); } void Test(void) { char *str = NULL; GetMemory(str); strcpy(str, "hello world"); printf(str); } 请问运行Test函数会有什么样的结果？ 答：程序崩溃。 因为GetMemory并不能传递动态内存， Test函数中的 str一直都是 NULL。 strcpy(str, "hello world");将使程序崩溃。 char *GetMemory(void) { char p[] = "hello world"; return p; } void Test(void) { char *str = NULL; str = GetMemory(); printf(str); } 请问运行Test函数会有什么样的结果？ 答：可能是乱码。 因为GetMemory返回的是指向“栈内存”的指针，该指针的地址不是 NULL，但其原现的内容已经被清除，新内容不可知。 void GetMemory2(char **p, int num) { *p = (char *)malloc(num); } void Test(void) { char *str = NULL; GetMemory(&str, 100); strcpy(str, "hello"); printf(str); } 请问运行Test函数会有什么样的结果？ 答： （1）能够输出hello （2）内存泄漏 void Test(void) { char *str = (char *) malloc(100); strcpy(str, “hello”); free(str); if(str != NULL) { strcpy(str, “world”); printf(str); } } 请问运行Test函数会有什么样的结果？ 答：篡改动态内存区的内容，后果难以预料，非常危险。 因为free(str);之后，str成为野指针， if(str != NULL)语句不起作用。 5、编写strcpy函数（10分） 已知strcpy函数的原型是 char *strcpy(char *strDest, const char *strSrc); 其中strDest是目的字符串，strSrc是源字符串。 （1）不调用C++/C的字符串库函数，请编写函数 strcpy char *strcpy(char* strDest, const char* strSrc) { assert((strDest!=NULL) && (strSrc !=NULL));//2分 char *address = strDest;//2分 while( (*strDest++ = * strSrc++) != ‘\0’ )//2分 NULL; return address;// 2分 } 5.1 strcpy能把strSrc的内容复制到strDest，为什么还要char * 类型的返回值？ 答：为了实现链式表达式。 // 2分 例如int length = strlen( strcpy( strDest, "hello world") ); 6、编写类String的构造函数、析构函数和赋值函数（25分） 已知类String的原型为： class String { public: String(const char *str = NULL);//普通构造函数 String(const String &other);//拷贝构造函数 ~ String(void);// 析构函数 String & operate =(const String &other);// 赋值函数 private: char* m_data;// 用于保存字符串 }; 请编写String的上述4个函数。 标准答案： // String的析构函数 String::~String(void) // 3分 { delete [] m_data; // 由于m_data是内部数据类型，也可以写成delete m_data; } // String的普通构造函数 String::String(const char *str) // 6分 { if(str==NULL) { m_data = new char[1]; // 若能加NULL 判断则更好 *m_data = ‘\0’; } else { int length = strlen(str); m_data = new char[length+1]; // 若能加NULL 判断则更好 strcpy(m_data, str); } } // 拷贝构造函数 String::String(const String &other) // 3分 { int length = strlen(other.m_data); m_data = new char[length+1]; // 若能加NULL 判断则更好 strcpy(m_data, other.m_data); } // 赋值函数 String & String::operate =(const String &other) // 13分 { // (1) 检查自赋值 // 4分 if(this == &other) return *this; // (2) 释放原有的内存资源 // 3分 delete [] m_data; // （）分配新的内存资源，并复制内容// 3分 int length = strlen(other.m_data); m_data = new char[length+1]; // 若能加NULL 判断则更好 strcpy(m_data, other.m_data); // （）返回本对象的引用 // 3分 return *this; } 7、实现双向链表删除一个节点P，在节点P后插入一个节点，写出这两个函数。 void DeleteNode(DuNode *p) { p->prior->next=p->next; p->next->prior=p->prior; } void InsertNode(DuNode *p, DuNode *s)//Node "s" is inserted after "p" { s->next=p->next; p->next->prior=s; p->next=s; s->prior=p; } 8、Windows程序的入口是哪里？写出Windows消息机制的流程。 WINDOWS入口是WinMain函数 消息机制的流程： 系统中发生了某个事件 Windows把这个事件翻译为消息，然后把它放到消息队列中 1. 应用程序从消息队列中接收到这个消息，把它存放在TMsg记录中 2. 应用程序把消息传递给一个适当的窗口的窗口过程 3. 窗口过程响应这个消息并进行处理 9．写一个函数，将其中的\t都转换成4个空格。 #include<iostream> using namespace std; char* Convert_t(char *des,char *src) { char *temp; des=new char[100]; temp=des; while(*src!='\0') { if(*src=='\t') { src++; *des++=' '; *des++=' '; *des++=' '; *des++=' '; continue; } *des++=*src++; } *des='\0'; des=temp; return des; } int main() { char *t="asdf\tasd\tasasddas\\tdfasdf",*d; cout<<t<<endl; cout<<Convert_t(d,t); getchar(); } 10．如何定义和实现一个类的成员函数为回调函数？ 如果类的成员函数是一个callback函数， 必须宣告它为"static"，才能把C++ 编译器加诸于函数的一个隐藏参数this去掉。 11．C++里面是不是所有的动作都是main()引起的？如果不是，请举例。 不是的，C＋＋里面有些动作不是引起的，比如，全局对象的实例化、全局变量的动态空间申请，等等 下面是一个例子： #include<iostream> using namespace std; char *des=new char[100]; //全局变量的动态空间申请在程序运行之后，main运行之前完成。所以不是所有的动作都是main引起的。 int main() { char *des="abc"; cout<<des<<endl; getchar(); } 12．C++里面如何声明const void f(void)函数为C程序中的库函数？ extern "C" const void f(void); 这样声明之后，相当于告诉C， 函数const void f(void)是在C＋＋语言的文件中声明或者实现的，c程序可以使用这个C＋＋中的函数了，从而实现C＋＋和c的混合编程。 13、编写一个函数，作用是把一个char组成的字符串循环右移n个。比如原来是“abcdefghi”如果n=2，移位后应该是“hiabcdefgh” 正确解答1： void LoopMove(char* pStr, int steps) { int n = strlen( pStr ) - steps; char tmp[MAX_LEN]; strcpy ( tmp, pStr + n ); strcpy ( tmp + steps, pStr); *( tmp + strlen ( pStr ) ) = '\0'; strcpy( pStr, tmp ); } 正确解答2： void LoopMove(char* pStr,int steps ) { int n = strlen( pStr ) - steps; char tmp[MAX_LEN]; memcpy( tmp, pStr + n, steps ); memcpy(pStr + steps, pStr, n ); memcpy(pStr, tmp, steps ); } 14、写出输出结果 void fun(char s[10]) { char a[10]; cout<<"a:"<<sizeof(a)<<endl; cout<<"s:"<<sizeof(s)<<endl; } 输出： a:10 s:4 15、内存的分配方式的分配方式有几种? 答: 1. 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量。 2. 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 3. 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。 16.是不是一个父类写了一个virtual 函数，如果子类覆盖它的函数不加virtual ,也能实现多态? 答：virtual修饰符会被隐形继承的。private 也被集成，只事派生类没有访问权限而已。virtual可加可不加。子类的空间里有父类的所有变量(static除外)。同一个函数只存在一个实体(inline除外)。子类覆盖它的函数不加virtual ,也能实现多态。在子类的空间里，有父类的私有变量。私有变量不能直接访问。 17.进程间通信的方式有? 进程间通信的方式有 共享内存， 管道 ，Socket ，消息队列 , DDE等 18.C++中什么数据分配在栈或堆中，New分配数据是在近堆还是远堆中？ 答：栈: 存放局部变量，函数调用参数,函数返回值，函数返回地址。由系统管理 堆: 程序运行时动态申请，new 和　malloc申请的内存就在堆上 (Google搜)：DOS下程序是独占方式，堆分为近堆和远堆，近堆和栈是在数据段开辟的同一块内存地址，栈从下往上增长，堆从上向下分配，中间没有规定分界线，所以程序控制不当，如深层次的递归，大量的动态地址分配很容易造成堆栈冲突，即堆栈地址重叠，从而造成死机和程序运行异常。堆和栈连在一起说的原因就是如此。至于远堆则是指在数据段和代码段以外计算机所有没有使用的剩余基本内存。Windows采用的是虚拟地址，内存分配方式就不一样了 补充：DOS下堆栈的分配是由程序而不是操作系统自己控制的，具体分配大小、方式随编译系统、程序模式不同而异。C语言的堆栈分配代码在启动代码中. 19.全局变量和局部变量在内存中是否有区别？如果有，是什么区别？ 全局变量储存在静态数据库，局部变量在堆栈。 20.TCP/IP 建立连接的过程?(3-way shake) 答：在TCP/IP协议中，TCP协议提供可靠的连接服务，采用三次握手建立一个连接。 第一次握手：建立连接时，客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认； 第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态； 第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。 21.winsock建立连接的主要实现步骤? 答：服务器端：socker()建立套接字，绑定（bind）并监听（listen），用accept（）等待客户端连接。 客户端：socker()建立套接字，连接（connect）服务器，连接上后使用send()和recv（），在套接字上写读数据，直至数据交换完毕，closesocket()关闭套接字。 服务器端：accept（）发现有客户端连接，建立一个新的套接字，自身重新开始等待连接。该新产生的套接字使用send()和recv（）写读数据，直至数据交换完毕，closesocket()关闭套接字。 22.static有什么用途？（请至少说明两种） 1) 在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。 2) 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。 3) 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用 23.引用与指针有什么区别？ 1) 引用必须被初始化，指针不必。 2) 引用初始化以后不能被改变，指针可以改变所指的对象。 3) 不存在指向空值的引用，但是存在指向空值的指针。 24、请写出下列代码的输出内容 #include<stdio.h> main() { int a,b,c,d; a=10; b=a++; c=++a; d=10*a++; printf("b，c，d：%d，%d，%d"，b，c，d); return 0; } 答：10，12，120 main() { int a[5]={1,2,3,4,5}; int *ptr=(int *)(&a+1); printf("%d,%d",*(a+1),*(ptr-1)); } 输出：2,5 *(a+1）就是a[1]，*(ptr-1)就是a[4],执行结果是2，5 &a+1不是首地址+1，系统会认为加一个a数组的偏移，是偏移了一个数组的大小（本例是5个int） int *ptr=(int *)(&a+1); 则ptr实际是&(a[5]),也就是a+5 原因如下： &a是数组指针，其类型为 int (*)[5]; 而指针加1要根据指针类型加上一定的值， 不同类型的指针+1之后增加的大小不同 a是长度为5的int数组指针，所以要加 5*sizeof(int) 所以ptr实际是a[5] 但是prt与(&a+1)类型是不一样的(这点很重要) 所以prt-1只会减去sizeof(int*) a,&a的地址是一样的，但意思不一样，a是数组首地址，也就是a[0]的地址，&a是对象（数组）首地址，a+1是数组下一元素的地址，即a[1],&a+1是下一个对象的地址，即a[5]
【c++】10. memset()、【strcpy_s()、memcpy_s()】、【strcpy()，memcpy()】
u011754972的博客
04-20 1404
选择使用memcpy_s，strcpy_s还是选择strcpy，memcpy? memset()的用法 memcpy_s，strcpy_s函数明确的指定了目标内存的大小，能够清晰的暴露出内存溢出的问题，而普通的strcpy，memcpy则不会。 为了保证内存拷贝有足够的空间，防止笔误，【尽量使用memcpy_s代替memcpy】。 (1)memcpy_s()的用法： errno_t memcpy_s( void *dest, size_t numberOfElements, const v
C++的Memcpy与Memcpy_s函数解析
smb_yy的博客
10-10 1万+
Memcpy函数 一. 函数内容 ** 1.1函数原型 ** void * Memcpy(void * dest,const void * src,size_t count)这是一个函数指针 接收的是一个地址 dest是接收地址的首地址，src是源首地址，count是接收目标的大小单位为字节 位于cstring或memcpy.h头文件中。 windows中Memcpy的函数原型 ...
【学习笔记】memcpy_s 函数与坑
noname 博客
08-17 9503
所以实际填写的值应该是 destSize 和 count 都为 10 * 4（即 10 个元素，每个元素占用 4 个字节）。函数赋值到 dest 中，最开始我以为 destSize 和 count 表示的是元素个数，于是填写的都是 10，如下。这里有一个坑，那就是关于 destSize 和 count 的值，它们都是指的字节数（最开始我以为是元素个数）。是在内存级别上直接进行拷贝操作，但注意它一次拷贝的数量为一个字节，而不是一个位（比特）。函数来计算 src 和 dest 占用的元素的字节数，
memcpy_s这类安全函数使用介绍(来自安全 C 库: Safe C Library )
热门推荐
To learn, to engage.
03-31 2万+
由memcpy_s引出对这类安全函数的介绍，并简单介绍其使用方式
C语言 strcpy_s 函数 - C语言零基础入门教程
猿说编程
08-12 5323
目录 一.strcpy_s 函数简介 1.strcpy 函数报错：error C4996 2.strcpy 函数没有方法来保证有效的缓冲区尺寸，使用不安全 二.strcpy_s 函数语法 三.strcpy_s 函数实战 1.strcpy_s 函数简单使用 2.strcpy_s 函数拷贝内容以’\0’结尾 四.猜你喜欢 零基础 C/C++ 学习路线推荐 : C/C++ 学习目录 >> C 语言基础入门 一.strcpy_s 函数简介 C 语言在 string.h 中 strcp
【c++中内存拷贝函数(C++ memcpy)详解】
qq_42222110的博客
02-21 8452
内存拷贝
安全函数strcpy_s、strncpy_s、snprintf_s、memcpy_s
11-01
用于了解安全函数strcpy_s、strncpy_s、snprintf_s、memcpy_s
C/C++中的mem函数和strcopy函数的区别和应用
01-20
即memcpy对于需要复制的内容没有限制，因此用途更广。 mem系列函数是面试的时候常考的知识点，我们需要熟练掌握这三个函数的原理和代码实现，要能准确无误的写出代码。 memcpy、memset和memset三个函数在使用过程中...
你必须知道的495个C语言问题
05-08
1.12　关键字auto到底有什么用途？ 类型定义(typedef) 1.13　对于用户定义类型，typedef和#define有什么区别？ 1.14　我似乎不能成功定义一个链表。我试过typedefstruct{char*item;NODEPTRnext;}*NODEPTR;但是...
c++下memcpy()、memset()、memcmp()需要注意的
weixin_30757793的博客
08-03 2101
memcpy()、memset()、memcmp()等这些内存操作函数经常会帮我们完成一些数据复制、赋值等操作。因为在C语言中，无论是内置类型，还是自定义的结构类型（struct），其内存模型对于我们来说都是可知的、透明的。所以，我们可以对该对象的底层字节序列一一进行操作，简单而有效。代码片段如下所示： structSTUDENT { char_name[32]; ...
C++ memcpy_s耗时测试
a553455的博客
09-04 1889
测试代码如下 const int length = 100 * 1024 * 1024; char* testme = new char[length]; char* testme2 = new char[length]; memset(testme2, 1, length); clock_t start = clock(); for (int i = 0; i < 100; i...
C++深拷贝和浅拷贝
GKoSon的博客
04-20 737
深拷贝和浅拷贝 发生的时间就是在赋值的时候 类似int A;int B; A=B 的时候 我们已经知道在C语言的时候 操作char *需要memcpy strcpy这样的函数不能直接等 但是结构体呢？这个时候你用memcpy就是深拷贝 而你用=就是浅拷贝 系统默认的就是浅拷贝 你要自己深拷贝的话 就自己写 拷贝构造函数 他是构造函数中的 一员 就在赋值时候调用 用一个去初始化另外一个 开始测...
详解memcpy和memmove函数的使用
m0_56911284的博客
09-13 3565
深入了解memcpy和memmove函数以及其实现。
用memcpy_s()安全复制字符串
huanghuan03的博客
03-30 937
用memcpy_s()安全复制字符串 字符串一生之敌QAQ 昨天在写字符串的时候赋值总是出现问题。常见的做法有： 1.不安全，导致缓冲区溢出，可以用strcpy_s替代 #define _CRT_SECURE_NO_WARNINGS ...... strcpy(char *strDestination,const char *strSource); 2.不安全，导致缓冲区溢出 #define _CRT_SECURE_NO_WARNINGS ...... memcpy(void *dest, c
C语言.动态内存管理
最新发布
Joseit的博客
05-16 588
栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS(操作系统)回收。分配方式类似于链表。数据段（静态区）：（static）存放全局变量、静态数据。程序结束后由系统释放。
memcpy_s函数
11-14
memcpy_s函数是C/C++语言中用于内存拷贝的函数，与memcpy函数类似，但提供了更多的安全性。其函数原型如下： ```c++ errno_t memcpy_s(void* destination, rsize_t destinationSize, const void* source, rsize_t num); ``` 其中，destination表示目标内存地址，destinationSize表示目标内存大小，source表示源内存地址，num表示要拷贝的字节数。 与memcpy函数不同的是，memcpy_s函数在执行拷贝操作时会检查目标内存地址和大小是否合法，以避免内存溢出和缓冲区溢出等安全问题。如果目标内存地址或大小不合法，memcpy_s函数会返回一个错误码，可以通过errno_t类型的返回值来判断是否拷贝成功。 下面是一个使用memcpy_s函数的示例： ```c++ #include <stdio.h> #include <string.h> int main() { char source[] = "Hello, world!"; char destination[20]; errno_t err; err = memcpy_s(destination, sizeof(destination), source, strlen(source) + 1); if (err == 0) { printf("Copied string: %s\n", destination); } else { printf("Error copying string: %d\n", err); } return 0; } ``` 在上面的示例中，我们定义了一个源字符串source和一个目标字符串destination。然后，使用memcpy_s函数将source中的数据拷贝到destination中。最后，输出拷贝后的字符串。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值