02
2020
04

宏定义的用法,看下面这个程序,求出结果

#include <stdio.h>#define S(a,b) a*b int main(void){int n = 3;int m = 5;printf("%d",S(n+m,m+n)); return 0;}这道题容易出现的错误结果是64,得到这个结果肯定是这样理解的(3+5)*(5+3)。其实并不是,大家要理解宏定义的概念,宏定义只是简单的符号替换,而不做其他处理,所以这里得到的结果是 3+5*5+3=31.大家看看运行结果:fs@
02
2020
04

a=3,b=5,不用第三变量temp,对a和b的值进行交换

如果有第三者temp,a和b交换非常方便:temp = a;a = b;b =temp;若无temp,可以这样做:a = a + b;b = a - b;a = a - b;当然,我们可以利用C语言的位运算符:a = 3;b = 5;a ^= b;b ^= a;a ^= b;原理是a ^ b ^ b == a; a ^ b == b ^ a;
02
2020
04

编码实现某一变量某位清0或置1

给定一个整型变量a,写两段代码,第一个设置a的bit 3,第二个清a的bit 3,在以上两个操作中,要保持其他位不变。笔者认为,在对ARM寄存器操作时会经常用到这一块,所以要注意这块:#define BIT3 (0x1 << 3 ) Satic int a;//设置a的bit 3: void set_bit3( void ) {       a |= BIT3; //将a第3位置1 }//清a的bit 3 
02
2020
04

用C编写一个死循环程序

while(){}其实还有for(;;)说明:很多种途径都可实现同一种功能,但是不同的方法时间和空间占用度不同,特别是对于嵌入式软件,处理器速度比较慢,存储空间较小,所以时间和空间优势是选择各种方法的首要考虑条件。
02
2020
04

extern有什么作用

extern标识的变量或者函数声明其定义在别的文件中,提示编译器遇到此变量和函数时在其它模块中寻找其定义。
02
2020
04

static有什么作用

static在C中主要用于定义全局静态变量、定义局部静态变量、定义静态函数。在C++中新增了两种作用:定义静态数据成员、静态函数成员。注意:因为static定义的变量分配在静态区,所以其定义的变量的默认值为0,普通变量的默认值为随机数,在定义指针变量时要特别注意。
02
2020
04

关键字const是什么

const用来定义一个只读的变量或对象。主要优点:便于类型检查、同宏定义一样可以方便地进行参数的修改和调整、节省空间,避免不必要的内存分配、可为函数重载提供参考。说明:const修饰函数参数,是一种编程规范的要求,便于阅读,一看即知这个参数不能被改变,实现时不易出错。
02
2020
04

typedef和define有什么区别

(1)用法不同:typedef用来定义一种数据类型的别名,增强程序的可读性。define主要用来定义常量,以及书写复杂使用频繁的宏。(2)执行时间不同:typedef是编译过程的一部分,有类型检查的功能。define是宏定义,是预编译的部分,其发生在编译之前,只是简单的进行字符串的替换,不进行类型的检查。(3)作用域不同:typedef有作用域限定。define不受作用域约束,只要是在define声明后的引用都是正确的。(4)对指针的操作不同:typedef和define定义的指针时有很大的区别
02
2020
04

编码实现直接选择排序

选择排序实现代码如下:#include <stdio.h> int main(){ int i,j,t; int array[10]={2,7,1,8,5,9,3,4,0,6}; printf("\nDisplay this array:\n"); for(i=0;i<10;i++) {  printf("%d ",array[i]); } prin
02
2020
04

编码实现冒泡排序

冒泡排序编程实现如下:#include <stdio.h>#define LEN 10 int main(){ int a,i,j; int ARRAY[10]={23,1,4,9,6,17,24,56,98,72}; printf("\n"); printf("Display this array:\n"); for(a=0;a<10;a++) {  pri
02
2020
04

编码实现直接插入排序

直接插入排序编程实现如下:#include <stdio.h> int main(){ int i,temp,p; int array[10] = {2,6,1,9,4,7,5,8,3,0}; printf("Display this array:\n"); for(i=0;i<10;i++) {  printf("%d ",array[i]); } &nbs
02
2020
04

简述队列和栈的异同

队列和栈都是线性存储结构,但是两者的插入和删除数据的操作不同,队列是“先进先出”,栈是“后进先出”。注意:区别栈区和堆区。堆区的存取是“顺序随意”,而栈区是“后进先出”。栈由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。堆一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收。分配方式类似于链表。它与本题中的堆和栈是两回事。堆栈只是一种数据结构,而堆区和栈区是程序的不同内存存储区域。
02
2020
04

链表与数组的区别

数组和链表有以下几点不同:(1)存储形式:数组是一块连续的空间,声明时就要确定长度。链表是一块可不连续的动态空间,长度可变,每个结点要保存相邻结点指针。(2)数据查找:数组的线性查找速度快,查找操作直接使用偏移地址。链表需要按顺序检索结点,效率低。(3)数据插入或删除:链表可以快速插入和删除结点,而数组则可能需要大量数据移动。(4)越界问题:链表不存在越界问题,数组有越界问题。说明:在选择数组或链表数据结构时,一定要根据实际需要进行选择。数组便于查询,链表便于插入删除。数组节省空间但是长度固定,
02
2020
04

简述strcpy sprintf与mencpy的区别

三者主要有以下不同之处:(1)操作对象不同,strcpy的两个操作对象均为字符串,sprintf的操作源对象可以是多种数据类型,目的操作对象是字符串,memcpy 的两个对象就是两个任意可操作的内存地址,并不限于何种数据类型。(2)执行效率不同,memcpy最高,strcpy次之,sprintf的效率最低。(3)实现功能不同,strcpy主要实现字符串变量间的拷贝,sprintf主要实现其他数据类型格式到字符串的转化,memcpy主要是内存块间的拷贝。说明:strcpy、sprintf与memc
02
2020
04

简述C、C++程序编译的内存分配情况

C、C++中内存分配方式可以分为三种:(1)从静态存储区域分配:内存在程序编译时就已经分配好,这块内存在程序的整个运行期间都存在。速度快、不容易出错,因为有系统会善后。例如全局变量,static变量等。(2)在栈上分配:在执行函数时,函数内局部变量的存储单元都在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。(3)从堆上分配:即动态内存分配。程序在运行的时候用malloc或new申请任意大小的内存,程序员自己负责在何时用fr
02
2020
04

a 和 &a 有什么区别

请写出以下代码的打印结果,主要目的是考察a和&a的区别。#include<stdio.h> void main( void ) {      int a[5]={1,2,3,4,5};     int *ptr=(int *)(&a+1);     printf("%d,%d",*(a+1),*(ptr-1)); &nb
02
2020
04

一个指针可以是volatile吗?

可以,因为指针和普通变量一样,有时也有变化程序的不可控性。常见例:子中断服务子程序修改一个指向一个buffer的指针时,必须用volatile来修饰这个指针。
02
2020
04

写一个“标准”宏MIN

#define min(a,b) ((a)<=(b)?(a):(b))
02
2020
04

sizeof和strlen的区别

sizeof和strlen有以下区别: sizeof是一个操作符,strlen是库函数。 sizeof的参数可以是数据的类型,也可以是变量,而strlen只能以结尾为‘\0‘的字符串作参数。 编译器在编译时就计算出了sizeof的结果。而strlen函数必须在运行时才能计算出来。并且sizeof计算的是数据类型占内存的大小,而strlen计算的是字符串实际的长度。 数组做sizeof的参数不退化,传递给strlen就退化为指针了。注意:有些是操作符看起来像是函数,而有些函数名看起来又像操
02
2020
04

实现strcat

 char* MyStrCat( char *pDest, const char *pSrc )    {         if( nullptr == pDest || nullptr == pSrc )         {             return nullptr;   &
02
2020
04

int (*s[10])(int) 表示的是什么?

int (*s[10])(int) 函数指针数组,每个指针指向一个int func(int param)的函数。
02
2020
04

将程序跳转到指定内存地址 要对绝对地址0x100000赋值,我们可以用(unsigned int*)0x100000 = 1234;那么要是想让程序跳转到绝对地址是0x100000去执行,应该怎么做?

((void ()( ))0x100000 ) ( );  首先要将0x100000强制转换成函数指针,即:  (void ()())0x100000  然后再调用它:  ((void ()())0x100000)();  用typedef可以看得更直观些:  typedef void()() voidFuncPtr;  *((voidFuncPtr)0x100000)();
02
2020
04

复杂声明 void * ( * (*fp1)(int))[10]; float (( fp2)(int,int,int))(int); int (* ( * fp3)())10; 分别表示什么意

【标准答案】1.void * ( * (fp1)(int))[10]; fp1是一个指针,指向一个函数,这个函数的参数为int型,函数的返回值是一个指针,这个指针指向一个数组,这个数组有10个元素,每个元素是一个void型指针。2.float (( fp2)(int,int,int))(int); fp2是一个指针,指向一个函数,这个函数的参数为3个int型,函数的返回值是一个指针,这个指针指向一个函数,这个函数的参数为int型,函数的返回值是float型。3.int (* ( * fp3)()
02
2020
04

const 与 #define 的比较 ,const有什么优点?

【参考答案】(1) const 常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换,没有类型安全检查,并且在字符替换可能会产生意料不到的错误(边际效应) 。(2) 有些集成化的调试工具可以对 const 常量进行调试,但是不能对宏常量进行调试。
02
2020
04

实现strcpy.

 char* MyStrCpy( char *pDest, const char *pSrc )    {        if( nullptr == pDest || nullptr == pSrc )        {           return nullptr;       
02
2020
04

C语言中数字转字符串的方法是什么?(itoa)请实现他

char* Myitoa( char *pDest, int val, int radix )   {       assert( NULL != pDest );       assert( radix > 1 );       const bool IsMinu = val < 0;       cha
02
2020
04

如何判断链表是否有环

bool IsLoop( Node *pHead )  {      //[H->A->B->C->A]       assert( NULL != pHead );       Node *pNext = pHead->mpNext;       Node *pNextNext = pHead->mp
02
2020
04

统计出一个字符串每种字母出现的次数要求时间复杂度为O(n)

void CountLetter( const char *pSrc )   {       int count[ 256 ] = {};      for( ; *pSrc !='\0'; ++pSrc )      {          const char &c = *pSrc;  &nb
02
2020
04

选择排序的思想是什么?( 每次找到最大或最小的值放在数组的低位上 )请实现它

void SelectSort( int *pArray, int count )  {      for( int i = 0; i < count; ++i )      {          //默认低位元素最小          int MinValue = pArray[ i ];    &n
02
2020
04

冒泡排序的思想是什么?(升序排序中越小的数往低位走,越大的数往高位走,每次与相邻元素比较导致的特点)请实现它

void BubbleSort( int *pArray, int count )   {       //eg.[6][8][8][0][9][1]      //i = 0,j < 5    [6][8][0][8][1][9]       //i = 1,j < 4    [6][0][8][1][8][9]
02
2020
04

已知两个数组有序实现一个方法将他们合并后任然有序

void MergeSort( int *pMerge, int *p1, int p1len, int *p2, int p2len )   {      assert( nullptr != pMerge && nullptr != p1 && nullptr != p2 );                  
02
2020
04

main 函数执行以前,还会执行什么代码?

答案:全局对象的构造函数会在main 函数之前执行。
02
2020
04

C++是不是类型安全的?

答案:不是。两个不同类型的指针之间可以强制转换(用reinterpret cast)。C#是类型安全的。
02
2020
04

实现一个算法找到数组中第二大的数

int FindSec( int *p, int len )    {      assert( nullptr != p );       int maxv = p[ 0 ];       int secv = p[ 0 ];      for( int i = 1; i < len; ++i )    &nb
02
2020
04

C与C++的区别?

C是面向过程,C++面向对象,C是C++的一个子集,C++还有继承多态分装等特性
02
2020
04

C++11的新特性?C++14?C++17

C++11:auto关键字,nullptr,for新用法( for(auto a: b) ), 智能指针,匿名函数(lambda)等 C++14:auto关键字扩展,泛型lambda C++17:
02
2020
04

指针和引用的区别?

1.指针是一个存储内存地址的变量,指向一个内存单元;引用是变量的别名 2.用const指针,没有const引用 3.指针可以为空,引用必须初始化,不能为null 4.有多级指针,但没有多级引用 5.指针初始化后可以指向其他存储单元,引用初始化后不能改变
02
2020
04

static和const区别?

const定义的常量在超出其作用域之后其空间会被释放,而static定义的静态常量在函数执行后不会释放其存储空间
02
2020
04

const和define的区别?

1.define在预处理阶段展开,const是在编译运行阶段使用 2.define没有类型检查,const在编译器有运行检查 3.define没有分配内存,const会分配存储空间 4.const可以节省空间,const常量在程序运行中只有一份拷贝(静态区), 而define有若干个拷贝 5.编译器通常不为普通const常量分配存储空间,而是将它们保存在符号表中,这使得它成为一个编译期间的常量,没有了存储与读内存的操作,使得它的效率也很高。 6.
02
2020
04

define和typedef的区别?

1.typedef常用于定义一个标识符及关键字的别名,不实际分配内存空间;define为宏定义语句,在预处理过程中完成,缺少类型检测 2.typdef和define不同,不仅仅是单纯的类型替换 例如#define INT int* typedef int* pINT;INT a, b;   //a是int*类型,b是intpINT c, d;  //c和d都是int*
02
2020
04

struct和class的区别?

1.两者都可以用成员函数,变量,以及可继承 2.struct默认权限为public, class为private 3.struct默认继承方式为public,class为private
02
2020
04

C++中的重载,覆盖,隐藏的区别?

1.重载:同一作用域内,函数名相同,但是参数的类型与顺序是不同的函数组为重载函数(不考虑返回值类型) 2.覆盖(重写):派生类中存在重新定义的函数。函数名,参数列表与返回值都和基类一致。基类的函数必须要有virtual修饰 3.隐藏:派生类存在和基类函数名相同的函数,基类可以不是virtual函数,参数列表和返回值也可以不同。
02
2020
04

C++多态的实现,虚函数原理

多态: 指当不同的对象收到相同的消息时,产生不同的动作 1.编译时多态(静态绑定):函数重载,运算符重载 2.运行时多态(动态绑定):虚函数 虚函数: 1.虚函数是通过一张虚函数表实现的(编译器处理虚函数的方法:为每个类对象添加一个隐藏成员,隐藏成员中保存了一个指向函数地址数组的指针,称为虚表指针,这种数组成为虚函数表) 2.虚函数表中主要存放勒种虚函数的地址,用于解决继承,重写的问题 3.继承的时候,若派生类重写了虚函数,则原先指向基
02
2020
04

C++如何实现一个接口

抽象类,使用纯虚函数
02
2020
04

C++虚继承的作用

用于解决多重继承的问题: 不同对象继承的同一基类会在子类中存在的多份拷贝,浪费存储空间,并且造成二义性 底层的实现:虚继承的时候,子类都会有一个虚基类的指针和虚基类表,所以基类只存在一份拷贝,避免了二义性
02
2020
04

C++中的构造函数

1.默认构造函数 2.一般构造函数 3.拷贝构造函数 4.转换构造函数
02
2020
04

C++的内存模型

1.堆区(动态区):用于存放new分配的变量 2.栈区:用于存放局部变量 3.静态存储区:用于保存全局变量和静态变量 4.常量存储区:存储常量,字符串常量等 5.代码区:存储代码 关于自由存储区网上意见不同,有的认为可以等价于堆区 5.自由存储区:存放malloc分配的变量
02
2020
04

浅拷贝和深拷贝

类中默认的复制构造函数进行的是浅拷贝。 1.浅拷贝只是对指针的拷贝,拷贝后指向同一内存空间;深拷贝不只是对指针拷贝,还对内容进行的拷贝,指向不同的地址 2.浅拷贝容易造成内存泄漏(析构的时候析构了两次)
02
2020
04

new/delete和malloc/free的区别

1.malloc/free是库函数, new/delete是操作符 2.malloc/free只是单纯的申请空间,new/delete还会调用构造函数和析构函数 3.malloc不抛出异常,new会抛出异常
02
2020
04

STL中unordered_map和map的区别

1.unordered_map底层为hashtable, map底层为红黑树 2.unordered_map是无序的
02
2020
04

STL中set和map的区别

1.两者的底层都是红黑树 2.set的节点是一个元素,map的节点是一对元素(key和value) 3.元素都会被自动排序 4.都不允许键值重复 5.set不能改变值,因为key=value;map可以通过key改变value
02
2020
04

STL红黑树的实现

1.红黑树是一个二叉搜索树 2.满足4条规则:a.节点不是红色就是黑色b.根节点为黑色c.如果节点为红色,子节点必须为黑色d.任意节点到null的黑色节点数相同) 3.通过旋转维持红黑树的结构
01
2020
04

封装、继承、多态、虚函数

a、封装:只隐藏对象的属性和实现细节,仅对外提供公共访问方式好处:将变化隔离、便于使用、提高复用性、提高安全性原则:将不需要对外提供的内容隐藏起来,把属性隐藏,提供公共方法对其访问b、继承:提高代码复用性;继承是多态的前提注:子类中所有的构造函数都会默认访问父类中的空参数的构造函数,默认第一行有super();若无空参数构造函数,子类中需指定;另外,子类构造函数中可自己用this指定自身的其他构造函数c、多态:是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象好处:提高了程序的扩展性弊
01
2020
04

什么是面向对象

面向对象是一种思想,是基于面向过程而言的,就是说面向对象是将功能通过对象来实现的,将功能封装进对象之中,让对象去实现具体的细节;这种思想是将数据作为第一位,而方法或者说是算法作为其次的。面向对象三大特征:封装性、继承性、多态性。其中封装性是指隐藏了对象的属性和实现细节,仅对外提供公共的访问方式,这样就隔离了具体的变化,便于使用,提高了复用性和安全性。对于继承性,就是两种事物间存在着一定的所属关系,那么继承的类就可以从被继承的类中获得一些属性和方法;这就提高了代码的复用性。继承是作为多态的前提的。
01
2020
04

C++和C的区别

C++在C的基础上添加类;C主要是面向过程的,C++主要是面向对象的;C主要考虑通过一个过程将输入经过各种运算后得到一个输出,C++主要考虑是如何构造一个对象模型,让这个模型契合与之对应的问题域,这样就可以通过获取对象的状态信息得到输出。
01
2020
04

用简介语言描述C++

C++是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言,支持过程化编程、面向对象编程和泛型编程。C++是一种中级语言,综合了高级语言和低级语言的特点。C++是C的一个超集,事实上,任何合法的C程序都是合法的C++程序。注:使用静态类型的编程语言是在编译时执行类型检查,而不是在运行时执行类型检查的。所以C++是在编译时执行类型检查的。
01
2020
04

#ifdef x #define x … #endif 作用

防止头文件在被多次引用的时候重复定义,这是C和C++的所有编译器通用的。但是微软的编译器还提供了另外一种方式#pragma once因为#ifdef ...这种方法是利用宏定义特性来保证不会被重复引用的,但是#ifdef 这个宏定义可以在文件的任何地方使用,所以编译器必须将文件读完才能完成工作。但是#pragma once是单独的一个宏定义,编译器只要可以立即标记,所以第二种更快,但无法跨平台。
01
2020
04

#include 和 #include ""的区别

#include用来指明引用的头文件,但是一般只有相对路径,不会引用完整路径。#include <> 表明从预定的缺省路径下找头文件,而#include ""表明先从本文件的当前目录下查找,如果没有,再按照#include <>预定的缺省路径下查找。
21
2020
03

以下为Windows NT下的32位C++程序,请计算sizeof的值

void Func ( char str[100] ) {  sizeof( str ) = ? } void *p = malloc( 100 ); sizeof ( p ) = ?sizeof( str ) = 4   sizeof ( p ) = 4  
21
2020
03

分别给出BOOL,int,float,指针变量 与“零值”比较的 if 语句

BOOL型变量:if(!var)   int型变量: if(var==0)   float型变量:   const float EPSINON = 0.00001;   if ((x >= - EPSINON) && (x <= EPSINON)   指针变量:if(var==NULL)   
21
2020
03

指出代码错误

void Test( void ) {  char *str = (char *) malloc( 100 );  strcpy( str, "hello" );  free( str );   ... //省略的其它语句 }错误有二:使用malloc分配内
21
2020
03

写出完整版的strcpy函数

char * strcpy( char *strDest, const char *strSrc )  {  assert( (strDest != NULL) && (strSrc != NULL) );  char *address = strDest;
21
2020
03

怎么判断两个链表是否有交点?

答:假设一个链表长为n,另一个链表长为m,让长的链表的指针先走|n-m|个长度,再让两个链表的指针一起走,最后两个指针相遇的地方就是交点了(画图!画图!)
21
2020
03

单向链表怎么取到倒数第k个元素?

答:设置两个指针p1p2,让p2 先走k步,然后再让p1p2同时走,最后若p2 指向的节点的下一个节点是NULL ,那么输出p1即可。(画个图就明白了)
21
2020
03

再扩展: 这个链表的长度是多少?

答:上一个问题我们自然可以得到起点到成环点的距离,那么再回到第一个问题的情况,p1p2相遇了,那么再让他们继续走下去,再次相遇所经过的操作数就是这个环的长度了,这两者相加就得到了整个链表的长度。
21
2020
03

扩展:并指出成环的点在哪里?

答:这个lz 也是在网上看了人家的博客才知道的,当p1p2 指向同一个节点的时候,让p1 指向第一个节点,p2 不动,然后让两个节点以同样的速度指向下一个节点,最后p1p2相遇的地方就是成环的点。
21
2020
03

单向链表如何判断是否成环?

答:两个指针p1,p2 , 其中p1 每次指向下一个节点,p2每次指向下两个节点(p2=p2->next->next),这样若链表有环,那么p1p2必定在某一点指向同一个节点。
21
2020
03

100大小的数组放了1-99 100个数,只有一个数重复了,找出重复的那个数。

答:解法很简单,把这100个数加起来,然后逐一剪掉1-99 剩下的那个数就是重复的数。
21
2020
03

老鼠喝药的问题:

就是告诉你,有n瓶药,里面有一瓶是毒药,老鼠喝了就会死,让你用最少的老鼠测出来,到底哪一瓶是毒药。答:利用二进制的思想,将所有的药水按照1-n的编号,对应的老鼠喝下二进制上对应位为1 的药水,观察老鼠死的状态,得到答案,比如说 3瓶药水,1号药水 01 2号药水 10 三号药水 11,那么最少需要2^2=4>3 ,两只老鼠就可以了,一号老鼠喝下2和3 号药水,二号老鼠喝下 1 和 3 号药水,要是一号老鼠挂掉了,二号老鼠没挂,证明毒药水是 10=2 号药水,以此类推。
21
2020
03

在什么时候需要使用“常引用”? 

如果既要利用引用提高程序的效率,又要保护传递给函数的数据不在函数中被改变,就应使用常引用。常引用声明方式:const 类型标识符 &引用名=目标变量名;例1int a ;const int &ra=a;ra=1; //错误a=1; //正确例2string foo( );void bar(string & s);那么下面的表达式将是非法的:bar(foo( ));bar("hello world");原因在于foo( )和"hello wor
21
2020
03

全局变量和局部变量有什么区别?是怎么实现的?操作系统和编译器是怎么知道的?

【参考答案】生命周期不同:全局变量随主程序创建和创建,随主程序销毁而销毁;局部变量在局部函数内部,甚至局部循环体等内部存在,退出就不存在;使用方式不同:通过声明后全局变量程序的各个部分都可以用到;局部变量只能在局部使用;分配在栈区。 操作系统和编译器通过内存分配的位置来知道的,全局变量分配在全局数据段并且在程序开始运行的时候被加载。局部变量则分配在堆栈里面 。
21
2020
03

基类的析构函数不是虚函数,会带来什么问题?

【参考答案】派生类的析构函数用不上,会造成资源的泄漏。
21
2020
03

内存的分配方式有几种?

【参考答案】一、从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量。二、在栈上创建。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。三、从堆上分配,亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存,程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定,使用非常灵活,但问题也最
21
2020
03

复杂声明 void * ( * (*fp1)(int))[10]; float (*(* fp2)(int,int,int))(int); int (* ( * fp3)())[10]();

【标准答案】                                                           1.void * ( * (*fp1)(int))[10]; &nbs
21
2020
03

const 与 #define 的比较 ,const有什么优点?

【参考答案】(1) const 常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换,没有类型安全检查,并且在字符替换可能会产生意料不到的错误(边际效应) 。(2)  有些集成化的调试工具可以对 const 常量进行调试,但是不能对宏常量进行调试。
21
2020
03

引用与指针有什么区别?

【参考答案】                         1) 引用必须被初始化,指针不必。2) 引用初始化以后不能被改变,指针可以改变所指的对象。3) 不存在指向空值的引用,但是存在指向空值的指针。
21
2020
03

int id[sizeof(unsigned long)];这个对吗?为什么?

 答案:正确 这个 sizeof是编译时运算符,编译时就确定了  ,可以看成和机器有关的常量。
21
2020
03

将程序跳转到指定内存地址

要对绝对地址0x100000赋值,我们可以用(unsigned int*)0x100000 = 1234;那么要是想让程序跳转到绝对地址是0x100000去执行,应该怎么做?  *((void (*)( ))0x100000 ) ( );  首先要将0x100000强制转换成函数指针,即:  (void (*)())0x100000  然后再调用它:  *((void (*)())0x100000)();  用typedef可以看得更直观些:  typedef void(*)() voidFun
21
2020
03

栈内存与文字常量区

    char str1[] = "abc";  char str2[] = "abc";  const char str3[] = "abc";  const char str4[] = "abc";  const char *str5 = "abc";  const char *str6 = "abc";  char *str7 = "abc
21
2020
03

int (*s[10])(int) 表示的是什么?

int (*s[10])(int) 函数指针数组,每个指针指向一个int func(int param)的函数。
21
2020
03

简述数组与指针的区别?

数组要么在静态存储区被创建(如全局数组),要么在栈上被创建。指针可以随时指向任意类型的内存块。(1)修改内容上的差别char a[] = “hello”;a[0] = ‘X’;char *p = “world”; // 注意p 指向常量字符串p[0] = ‘X’; // 编译器不能发现该错误,运行时错误(2) 用运算符sizeof 可以计算出数组的容量(字节数)。sizeof(p),p 为指针得到的是一个指针变量的字节数,而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量,
21
2020
03

请说出const与#define 相比,有何优点?

答案:const作用:定义常量、修饰函数参数、修饰函数返回值三个作用。被Const修饰的东西都受到强制保护,可以预防意外的变动,能提高程序的健壮性。1) const 常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换,没有类型安全检查,并且在字符替换可能会产生意料不到的错误。2) 有些集成化的调试工具可以对const 常量进行调试,但是不能对宏常量进行调试。
21
2020
03

分别写出BOOL,int,float,指针类型的变量a 与“零”的比较语句。

答案:BOOL : if ( !a ) or if(a)int : if ( a == 0)float : const EXPRESSION EXP = 0.000001if ( a < EXP && a >-EXP)pointer : if ( a != NULL) or if(a == NULL)19.请说出const与#define 相比,有何优点?
21
2020
03

描述内存分配方式以及它们的区别?

1) 从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量,static 变量。2) 在栈上创建。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。3) 从堆上分配,亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存,程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定,使用非常灵活,但问题也最多。
21
2020
03

main 函数执行以前,还会执行什么代码?

答案:全局对象的构造函数会在main 函数之前执行。
21
2020
03

C++是不是类型安全的?

答案:不是。两个不同类型的指针之间可以强制转换(用reinterpret cast)。C#是类型安全的。
21
2020
03

有哪几种情况只能用intialization list 而不能用assignment?

答案:当类中含有const、reference 成员变量;基类的构造函数都需要初始化表。
21
2020
03

重载(overload)和重写(overried,有的书也叫做“覆盖”)的区别?

常考的题目。从定义上来说:重载:是指允许存在多个同名函数,而这些函数的参数表不同(或许参数个数不同,或许参数类型不同,或许两者都不同)。重写:是指子类重新定义父类虚函数的方法。从实现原理上来说:重载:编译器根据函数不同的参数表,对同名函数的名称做修饰,然后这些同名函数就成了不同的函数(至少对于编译器来说是这样的)。如,有两个同名函数:function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称
21
2020
03

试写出程序结果:

int  a=4;int  &f(int  x){    a=a+x;      return  a;}int main(void){    int   t=5;     cout<<f(t)<<endl;  a = 9    f(t)=20;      
21
2020
03

结构与联合有和区别?

(1). 结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选中的成员(所有成员共用一块地址空间), 而结构的所有成员都存在(不同成员的存放地址不同)。 (2). 对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的。
21
2020
03

将“引用”作为函数返回值类型的格式、好处和需要遵守的规则?

格式:类型标识符 &函数名(形参列表及类型说明){ //函数体 }好处:在内存中不产生被返回值的副本;(注意:正是因为这点原因,所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束,相应的引用也会失效,产生runtime error! 注意事项:(1)不能返回局部变量的引用。这条可以参照Effective C++[1]的Item 31。主要原因是局部变量会在函数返回后被销毁,因此被返回的引用就成为了"无所指"的引用,程序会进入未知状态。(2)
21
2020
03

在什么时候需要使用“常引用”?

如果既要利用引用提高程序的效率,又要保护传递给函数的数据不在函数中被改变,就应使用常引用。常引用声明方式:const 类型标识符 &引用名=目标变量名;例1int a ;const int &ra=a;ra=1; //错误a=1; //正确例2string foo( );void bar(string & s);那么下面的表达式将是非法的:bar(foo( ));bar("hello world");原因在于foo( )和"hello wor
21
2020
03

将“引用”作为函数参数有哪些特点?

(1)传递引用给函数与传递指针的效果是一样的。这时,被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用,所以在被调函数中对形参变量的操作就是对其相应的目标对象(在主调函数中)的操作。(2)使用引用传递函数的参数,在内存中并没有产生实参的副本,它是直接对实参操作;而使用一般变量传递函数的参数,当发生函数调用时,需要给形参分配存储单元,形参变量是实参变量的副本;如果传递的是对象,还将调用拷贝构造函数。因此,当参数传递的数据较大时,用引用比用一般变量传递参数的效率和所占空间都好。(3)
21
2020
03

什么是“引用”?申明和使用“引用”要注意哪些问题?

答:引用就是某个目标变量的“别名”(alias),对应用的操作与对变量直接操作效果完全相同。申明一个引用的时候,切记要对其进行初始化。引用声明完毕后,相当于目标变量名有两个名称,即该目标原名称和引用名,不能再把该引用名作为其他变量名的别名。声明一个引用,不是新定义了一个变量,它只表示该引用名是目标变量名的一个别名,它本身不是一种数据类型,因此引用本身不占存储单元,系统也不给引用分配存储单元。不能建立数组的引用。
21
2020
03

求下面函数的返回值(微软)

int func(x) { int countx = 0; while(x) { countx ++; x = x&(x-1); } return countx; } 假定x = 9999。 答案:8思路:将x转化为2进制,看含有的1的个数。
21
2020
03

多态,虚函数,纯虚函数

多态:是对于不同对象接收相同消息时产生不同的动作。C++的多态性具体体现在运行和编译两个方面:在程序运行时的多态性通过继承和虚函数来体现;在程序编译时多态性体现在函数和运算符的重载上;虚函数:在基类中冠以关键字 virtual 的成员函数。 它提供了一种接口界面。允许在派生类中对基类的虚函数重新定义。纯虚函数的作用:在基类中为其派生类保留一个函数的名字,以便派生类根据需要对它进行定义。作为接口而存在 纯虚函数不具备函数的功能,一般不能直接被调用。从基类继承来的纯虚函数,在派生类中仍是虚函数。如果
21
2020
03

子类析构时要调用父类的析构函数吗?

析构函数调用的次序是先派生类的析构后基类的析构,也就是说在基类的的析构调用的时候,派生类的信息已经全部销毁了。定义一个对象时先调用基类的构造函数、然后调用派生类的构造函数;析构的时候恰好相反:先调用派生类的析构函数、然后调用基类的析构函数。
21
2020
03

C++有哪些性质(面向对象特点)

封装,继承和多态。
21
2020
03

delete与 delete []区别

delete只会调用一次析构函数,而delete[]会调用每一个成员的析构函数。在More Effective C++中有更为详细的解释:“当delete操作符用于数组时,它为每个数组元素调用析构函数,然后调用operator delete来释放内存。”delete与new配套,delete []与new []配套MemTest *mTest1=new MemTest[10];MemTest *mTest2=new MemTest;Int *pInt1=new int [10];Int *pIn
21
2020
03

new、delete、malloc、free关系

delete会调用对象的析构函数,和new对应free只会释放内存,new调用构造函数。malloc与free是C++/C语言的标准库函数,new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。对于非内部数据类型的对象而言,光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数,对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符,不在编译器控制权限之内,不能够把执行构造函数和析构函数的任务强加于malloc/free。