C证心理辅导笔试题

C证心理辅导笔试题（共9篇）

1.C证心理辅导笔试题 篇一

部分c/c++笔试题

c/c++笔试题如下：

1、请定义一个宏，比较两个数a、b的大小，不能使用大于、小于、if语句

#define Max(a,b)  ( a/b)?a:b

2、如何输出源文件的标题和目前执行行的行数

int line = __LINE__；

char *file = __FILE__；

cout<<“file name is ”<<(file)<<“,line is ”<

3、两个数相乘，小数点后位数没有限制，请写一个高精度算法

4、写一个病毒

while (1)

{

int *p = new int[10000000]；

}

5、不使用额外空间,将 A,B两链表的.元素交*归并

6、将树序列化 转存在数组或 链表中

struct st{

int i；

short s；

char c；

}；

sizeof(struct st)；

7、

char * p1；

void * p2；

int p3；

char p4[10]；

sizeof(p1...p4) =?

8、

4，4，4，10

二分查找

快速排序

双向链表的删除结点

2.c经典笔试题 篇二

#include

#include

void BubbleSort(int arr, int n)

{

int i,j;

int exchange = 1;//交换标志,提高算法效率;

int temp;

for(i=0;i

{

exchange=0;//本趟排序开始前，交换标志应为假

for(j=0;j

{

if(arr[j+1] > arr[j])

{

temp=arr[j+1];

arr[j+1]=arr[j];

arr[j]=temp;

exchange=1; //发生了交换，故将交换标志置为真

}

}

if(!exchange) //本趟排序未发生交换，提前终止算法

return;

}

}

int main(int argc,char* argv)

{

int arr[5]={1,4,2,6,5};

int i;

BubbleSort(arr, 5);

printf(“after sort,arr is :n”);

for(i=0;i<5;i++)

{

printf(“%3d”,arr[i]);

}

return 1;

3.C笔试题算法 篇三

这是最原始，也是众所周知的最慢的算法了。他的名字的由来因为它的工作看来象是冒泡： #include

void BubbleSort(int* pData,int Count)

{

int iTemp;

for(int i=1;i

{

for(int j=Count-1;j>=i;j--)

{

if(pData[j]

{

iTemp = pData[j-1];

pData[j-1] = pData[j];

pData[j] = iTemp;

}

}

}

}

void main

{

int data = {10,9,8,7,6,5,4};

BubbleSort(data,7);

for (int i=0;i<7;i++)

cout<

}

倒序

第一轮：10,9,8,7->10,9,7,8->10,7,9,8->7,10,9,8(交换3次)

第二轮：7,10,9,8->7,10,8,9->7,8,10,9(交换2次)

第一轮：7,8,10,9->7,8,9,10(交换1次)

循环次数：6次

交换次数：6次

其他：

第一轮：8,10,7,9->8,10,7,9->8,7,10,9->7,8,10,9(交换2次)

第二轮：7,8,10,9->7,8,10,9->7,8,10,9(交换0次)

第一轮：7,8,10,9->7,8,9,10(交换1次)

循环次数：6次

交换次数：3次

上面我们给出了程序段，现在我们分析它：这里，影响我们算法性能的主要部分是循环和交换，显然，次数越多，性能就越差。从上面的程序我们可以看出循环的次数是固定的，为1+2+...+n-1。 写成公式就是1/2*(n-1)*n。

现在注意，我们给出O方法的定义：

若存在一常量K和起点n0，使当n>=n0时，有f(n)<=K*g(n),则f(n) = O(g(n))。(呵呵，不要说没学好数学呀，对于编程数学是非常重要的!!!)

现在我们来看1/2*(n-1)*n，当K=1/2，n0=1，g(n)=n*n时，1/2*(n-1)*n<=1/2*n*n=K*g(n)。所以(n)=O(g(n))=O(n*n)。所以我们程序循环的复杂度为O(n*n)。

4.C笔试题及答案 篇四

#include

main

{

int a;float b，c;

scanf(“%2d%3P%4f’,&a,&b,&C);

printf(”na=%d，b=%ec。%fn”，a，b，C);

}

若运行时从键盘上输入9876543210l，则上面程序的输出结果是________。

A)a=98,b=765,c=432 1

B)a=1 0,b=432,c=8765

C)a=98,b=765.000000,c=432 1.000000

D)a=98,b=765.0,c=432 1.0

答案：C

评析：scanf把用户从键盘录入的数字的第1、2位存入整型变量a;把第3、4、5位存入单精度实型变量b，把第6、7、8、9位存入单精度实型变量c，用户录入的第10位被scanf遗弃。这时变量a、b、c的值分别为：98、765.000000、4321.000000。

(2)一个良好的算法由下面的基本结构组成，但不包括__________。

A)顺序结构 B)选择结构 C)循环结构 D)跳转结构

答案：D

评析：1966年，Bohra和Jacopini提出了以下三种基本结构，用这三种基本结构作为表示一个良好算法的基本单元：1、顺序结构;2、选择结构;3、循环结构。

(3)请选出以下程序的输出结果________。

#include

sub(x,y,z)

int x,y,*z：

{*z=y-x;}

main{

int a,b,c;

sub(10，5，&a);sub(7，a，&b);sub(a，b，&C);

printf(”%d，%d，%dn”，a，b，C);

}

A)5,2,3 B)-5，-12,-7 C)-5，-12,-17 D)5,-2,-7

答案：B

评析：sub函数的作用是将形参y和x的差赋给了z指向的那个内存地址，所以在sub(10,5,&a/I，10和5属于值传递，a是属于地址传递，也就是a与z指向了同一个存储单元，在执行函数后，a的值随*z变化，所以此次函数被调用后，a的值为y-x=-5，同理可知，在sub(7,a,&b)后，b的值发生变化，其值为-5-7=-12，在sub(a,b,&C)后，c的值发生变化，其值为-12-(-5)=-7。

(4)下面程序在屏幕上的输出是________。

main

{

printf(”abbb c”);

}

A)abbb c B)a c C)abc D)ab c

答案：B

评析：c语言中允许使用一种特殊形式的字符常量，、就是以一个“”开头的字符序列，这样的字符称为“转义字符”。常用的转义字符有：n，换行;t，水平制表;b，退格;r，回车。

(5)若x是整型变量，pb是基类型为整型的指针变量，则正确的赋值表达式是_______。

A)pb=&x; B)pb=x; C)*pb=&x; D)*pb=

答案：A

评析：选项A将变量x的地址赋给指针变量pb，使pb指向x‘选项B是将x的值当作地址赋给指针pb，Db指向一个地址等于x值的内存单元;选项c将x的地址赋给指针pb指向的地址等于x的内存单元。

(6)设整型数i=5，则printf(“%d”，i+++++i);的输出为________。

A)10 B)1l C)12 D)语法错误

答案：D

评析：c语言中有基本的算术运算符(+、-、*、/)还包括自增自减运算符(++、–)，在c语言解析表达式时，它总是进行贪婪咀嚼，这样，该表达式就被解析为i++ ++ +i，显然该表达式不合c语言语法。

(7)若要用下面的程序片段使指针变量p指向一个存储整型变量的动态存储单元

int *p;

p=___________malloc(sizeof(im));

则应填入__________。

A)int B)int C)(*int) D)(int*)

答案：D

评析：不论p是指向什么类型的指针变量，都可以通过强制类型转换的方法使之类型一致，强制类型转换的格式为(数据类型+)。

(8)下面程序输出的结果是__________。

main

{

int i=5,J=9，x;

x=(I==j?i：(j=7));

printf(”n%d，%d”，I,J);

}

A)5,7 B)5,5 C)语法错误 D)7,5

答案：A

评析：条件表达式的一般形式为：表达式I?表达式2：表达式3;先求解表达式1，若为真则求解表达式2;若表达式l的值为假，则求解表达式3。本题中先判断i==j，不等，执行j=7;然后执行x=7。故本题为A。

(9)若执行下面程序时从键盘上输入5，

main

{

int x：

scanf(”%d”，&x);

if(x++>5)printf(”%dn”，x);

else printf(”%dn”,x–);

}

则输出是________。

A)7 B)6 C)5 D)4

答案：B

评析：根据c语言的语法，x++是在使用x之后，再将x的值加1，在if语句中，x的值为5，条件不成立，执行else后面的语句，因为x的值已经加1，为6，所以打印结果为6。

(10)若有以下定义和语句：

int a={l，2，3，4，5，6，7，8，9,10}，*p=a;

则值为3的表达式是_________。

A)p+=2，*(p++) B)p+=2，*++p

C)p+=3，*p++ D)p+=2，++*p

答案：A

5.C/C++程序员常见笔试题 篇五

试题1：分别给出BOOL，int，float，指针变量 与“零值”比较的 if 语句(假设变量名为var)

解答：

BOOL型变量：if(!var)

int型变量： if(var==0)

float型变量：

const float EPSINON = 0.00001;

if ((x >= – EPSINON) && (x <= EPSINON)

指针变量： if(var==NULL)

剖析：

考查对0值判断的“内功”，BOOL型变量的0判断完全可以写成if(var==0)，而int型变量也可以写成if(!var)，指针变量的判断也可以写成if(!var)，上述写法虽然程序都能正确运行，但是未能清晰地表达程序的意思，

一般的，如果想让if判断一个变量的“真”、“假”，应直接使用if(var)、if(!var)，表明其为“逻辑”判断;如果用if判断一个数值型变量 (short、int、long等)，应该用if(var==0)，表明是与0进行“数值”上的比较;而判断指针则适宜用if(var==NULL)，这是一种很好的编程习惯。

浮点型变量并不精确，所以不可将float变量用“==”或“!=”与数字比较，应该设法转化成“>=”或“<=”形式。如果写成if (x == 0.0)，则判为错，得0分。

试题2：以下为Windows NT下的`32位C++程序，请计算sizeof的值

void Func ( char str[100] )

{

sizeof( str ) = ?

}

void *p = malloc( 100 );

sizeof ( p ) = ?

解答：

sizeof( str ) = 4

sizeof ( p ) = 4

剖析：

Func ( char str[100] )函数中数组名作为函数形参时，在函数体内，数组名失去了本身的内涵，仅仅只是一个指针;在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。

数组名的本质如下：

(1)数组名指代一种数据结构，这种数据结构就是数组;

例如：

char str[10];

cout << sizeof(str) << endl;

输出结果为10，str指代数据结构char[10]。

(2)数组名可以转换为指向其指代实体的指针，而且是一个指针常量，不能作自增、自减等操作，不能被修改;

char str[10];

str++; //编译出错，提示str不是左值

(3)数组名作为函数形参时，沦为普通指针。

Windows NT 32位平台下，指针的长度(占用内存的大小)为4字节，故sizeof( str ) 、sizeof ( p ) 都为4。

试题3：写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。另外，当你写下面的代码时会发生什么事?

least = MIN(*p++, b);

解答：

#define MIN(A,B) ((A) <= (B) ? (A) : (B))

MIN(*p++, b)会产生宏的副作用

剖析：

这个面试题主要考查面试者对宏定义的使用，宏定义可以实现类似于函数的功能，但是它终归不是函数，而宏定义中括弧中的“参数”也不是真的参数，在宏展开的时候对“参数”进行的是一对一的替换，

程序员对宏定义的使用要非常小心，特别要注意两个问题：

(1)谨慎地将宏定义中的“参数”和整个宏用用括弧括起来。所以，严格地讲，下述解答：

#define MIN(A,B) (A) <= (B) ? (A) : (B)

#define MIN(A,B) (A <= B ? A : B )

都应判0分;

(2)防止宏的副作用。

宏定义#define MIN(A,B) ((A) <= (B) ? (A) : (B))对MIN(*p++, b)的作用结果是：

((*p++) <= (b) ? (*p++) : (*p++))

这个表达式会产生副作用，指针p会作三次++自增操作。

除此之外，另一个应该判0分的解答是：

#define MIN(A,B) ((A) <= (B) ? (A) : (B));

这个解答在宏定义的后面加“;”，显示编写者对宏的概念模糊不清，只能被无情地判0分并被面试官淘汰。

试题4：为什么标准头文件都有类似以下的结构?

#ifndef __INCvxWorksh

#define __INCvxWorksh

#ifdef __cplusplus

extern “C” {

#endif

/*…*/

#ifdef __cplusplus

}

#endif

#endif /* __INCvxWorksh */

解答：

头文件中的编译宏

#ifndef __INCvxWorksh

#define __INCvxWorksh

#endif

的作用是防止被重复引用。

作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在symbol库中的名字与C语言的不同。例如，假设某个函数的原型为：

void foo(int x, int y);

该函数被C编译器编译后在symbol库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。_foo_int_int这样的名字包含了函数名和函数参数数量及类型信息，C++就是考这种机制来实现函数重载的。

为了实现C和C++的混合编程，C++提供了C连接交换指定符号extern “C”来解决名字匹配问题，函数声明前加上extern “C”后，则编译器就会按照C语言的方式将该函数编译为_foo，这样C语言中就可以调用C++的函数了。

试题5：编写一个函数，作用是把一个char组成的字符串循环右移n个。比如原来是“abcdefghi”如果n=2，移位后应该是“hiabcdefgh”

函数头是这样的：

//pStr是指向以’′结尾的字符串的指针

//steps是要求移动的n

void LoopMove ( char * pStr, int steps )

{

//请填充…

}

解答：

正确解答1：

6.C工程师笔试题 篇六

这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用：

1). 在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。

2). 在模块内(但在函数体外)，一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。

3). 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。(本地化数据和代码范围的好处和重要性)。

2、“引用”与指针的区别是什么?

答 、1) 引用必须被初始化，指针不必。

2) 引用初始化以后不能被改变，指针可以改变所指的对象。

3) 不存在指向空值的引用，但是存在指向空值的指针。

指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差;而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。

流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。

3、.h头文件中的ifndef/define/endif 的作用?

答：防止该头文件被重复引用。

4、#include 与 #include “file.h”的区别?

答：前者是从Standard Library的路径寻找和引用file.h，而后者是从当前工作路径搜寻并引用file.h。

5、描述实时系统的基本特性

答 ：在特定时间内完成特定的任务，实时性与可靠性。

6、全局变量和局部变量在内存中是否有区别?如果有，是什么区别?

答 ：全局变量储存在静态数据区，局部变量在堆栈中。

7、什么是平衡二叉树?

答 ：左右子树都是平衡二叉树 且左右子树的深度差值的绝对值不大于1。

8、堆栈溢出一般是由什么原因导致的?

答 ：1.没有回收垃圾资源2.层次太深的递归调用

9、冒泡排序算法的时间复杂度是什么?答 ：O(n^2)

7.C语言字符串笔试题 篇七

[cpp] view plain copy print?

#include

#include

#include

#define N 30 //s所指字符串的最大长度

#define T 2 //t1和t2所指字符串的长度

/

*函数名称： fun

*创建时间： 20xx.12.5

*描 述： 将s所指字符串中最后一次出现的与t1所指字符串相同的子串替换为t2所指字符串

*参 数： char * s,char * t1, char * t2,int *m

*返 回 值： w(数组w的首元素地址)

*局部变量： char w[N];

* char temp[T];

* char t1temp[T];

* int i,j,k,l;

/

char * fun(char * s,char * t1, char * t2,int *m) //m的作用和第一题一样，没m最后两个字符会乱码(想寻求其他方法)

{

char w[N]; //用来存放处理后的字符串

char temp[T]; //用来存放从s所指字符串中截取的子串

char t1temp[T]; //用来存放t1所指字符串

int i,j,k,l;

//向t1temp中存入t1所指字符串

for (i=0; i

{

t1temp[i]=t1[i];

}

t1temp[T]=';

//求m所指的值

for (i=0;i

{

if (s[i]==')

{

*m=i;

}

}

//寻找相同时的最后一个字符的下标

for (i=0; i

{

l=0;

for (j=i; j<(i+T); j++,l++) //截取长度为T的子串存到temp中

{

temp[l]=s[j];

}

temp[T]=';

if (strcmp(t1temp,temp) == 0)

{

k=i; //k记录相同时的最后一个字符的下标

}

}

for (i=0; i

{

j=0;

if (i>=k && i<(k+T)) //在找到的k点处开始换值

{

w[i]=t2[j]; //换值

j++;

}

else

{

w[i]=s[i];

}

}

return w;

}

//主函数

void main

{

char s[N];

char t1[T];

char t2[T];

int i;

int m;

char *p;

p=NULL;

printf(“请输入字符串(20字符以内):”);

scanf(“%s”,s);

printf(“请输入将要被替换的子字符串(仅限两个字符):”);

scanf(“%s”,t1);

printf(“请输入将要用来替换的字字符串(仅限两个字符):”);

scanf(“%s”,t2);

p=fun(s,t1,t2,&m);

for (i=0; i

{

s[i]=p[i];

}

printf(“结果为：”);

for (i=0; i

{

printf(“%c”,s[i]);

}

printf(“n”);

8.C语言开发工程师笔试题 篇八

在二叉树中找出和为某一输入值的所有路径。

#include

void getPath(struct treeNode星符号 node, int sum, vector& stack, int currentSum) { //stack用来存放路径,sum为输入值

} if (node == NULL) return; currentSum += node->id; stack.push_back(node->id); if (node->lchild != NULL) getPath(node->lchild, sum, stack, currentSum); if (node->rchild != NULL) getPath(node->rchild, sum, stack, currentSum); if (node->lchild == NULL && node->rchild == NULL) { if (currentSum == sum) { vector::iterator it = stack.begin; for (; it != stack.end; ++it) printf(”%d “, 星符号it); printf(”/n“); } } stack.pop_back;

9.C和C经典笔试题及答案 篇九

答案:必须使用静态成员变量在一个类的所有实例间共享数据.如果想限制对静态成员变量的访问,则必须把他们声明成保护型或私有型.不允许使用静态成员变量去存放一个对象的数据。静态成员数据是在这个类的所有对象间共享的。

静态数据成员：静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。节省内存;提高时间效率。使用静态数据成员可以因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一样，但它的值是可以更新的。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，

1、静态数据成员在定义或说明时前面加关键字static。

2、静态成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式如下：

<数据类型><类名>::<静态数据成员名>=<值>

这表明：

(1) 初始化在类体外进行，而前面不加static，以免与一般静态变量或对象相混淆。

(2) 初始化时不加该成员的访问权限控制符private，public等。

(3) 初始化时使用作用域运算符来标明它所属类，静态数据成员是类的成员，而不是对象的成员。

3、静态数据成员是静态存储的，它是静态生存期，必须对它进行初始化。

4、引用静态数据成员时，采用如下格式：

<类名>::<静态成员名>

静态数据成员的访问权限允许的话(即public的成员)，可在程序中，按上述格式来引用静态数据成员。

下面举一例子，说明静态数据成员的应用：

#include

class Myclass

{

public:

Myclass(int a, int b, int c);

void GetNumber;

void GetSum;

private:

int A, B, C;

static int Sum;

};

int Myclass::Sum = 0;

Myclass::Myclass(int a, int b, int c)

{

A = a;

B = b;

C = c;

Sum += A+B+C;

}

void Myclass::GetNumber

{

cout<<”Number=”<

}

void Myclass::GetSum

{

cout<<”Sum=”<

}

void main

{

Myclass M(3, 7, 10),N(14, 9, 11);

M.GetNumber;

N.GetNumber;

M.GetSum;

N.GetSum;

}

从输出结果可以看到Sum的值对M对象和对N对象都是相等的。这是因为在初始化M对象时，将M对象的三个int型数据成员的值求和后赋给了Sum，于是Sum保存了该值。在初始化N对象时，对将N对象的三个int型数据成员的值求和后又加到Sum已有的值上，于是Sum将保存另后的值。所以，不论是通过对象M还是通过对象N来引用的值都是一样的，即为54。

静态成员函数

静态成员函数和静态数据成员一样，它们都属于类的静态成员，它们都不是对象成员。因此，对静态成员的引用不需要用对象名。

在静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员。如果静态成员函数中要引用非静态成员时，可通过对象来引用。下面通过例子来说明这一点。

#include

class M

{

public:

M(int a) { A=a; B+=a;}

static void f1(M m);

private:

int A;

static int B;

};

void M::f1(M m)

{

cout<<”A=”<

cout<<”B=”<

}

int M::B=0;

void main

{

M P(5),Q(10);

M::f1(P); file://调用时不用对象名

M::f1(Q);

}

读者可以自行分析其结果。从中可看出，调用静态成员函数使用如下格式：

<类名>::<静态成员函数名>(<参数表>);

2.判断选择

1. C++语言没有可移植性。 B不正确

2. 定义数组时可以不确定元素个数。 B不正确

3. 指针是一种特殊的变量，只能用来保存地址。 A正确

4. 通过引用或者指针调用对象的成员函数时，如果引用或者指针的类型跟对象的类型不一致时，能自动正确调用对象所属的类中对这个函数的定义。 B不正确

5.类myclass，为myclass类对象以成员函数形式重载后++运算符的声明应该为 C myclass operator++( int );

A. myclass operator++;

B. myclass& operator++;

C. D. myclass& operator++( int );

5. 父类和子类各自定义一个成员函数，函数名相同，参数表不同，那么 C子类中的函数会覆盖父类中的函数。 函数同名,通通覆盖,不同层次的函数不能重载

6. 如果myclass类定义了拷贝构造函数和一个整型参数的构造函数，还重载了赋值运算符，那么语句

myclass obj = 100;会 B调用整型参数的构造函数。等价于 myclass obj = myclass(100)

7. 抽象类指的是 D有纯虚函数的类

8. 多重继承时，如果派生类的两个父类有一个共同的虚基类，那么虚基类的初始化参数由 C派生类

的构造函数来传递。

9. 多态性是通过 C虚函数 实现的。

10. 如果有如下语句

char str[20];

cin >> str;

cout << str;

执行时输入的是“this is a test line!”，则输出的内容是 D 。

A. this is a test line!

B. this is a test line

C. this is a test

D. this

11. 执行语句

char ch = “Hello”;

char * p = &ch[0];

cout << p;

结果是输出 C 。Hello

3.以下生面是否正确?

Class A{ const int size=0;};

答案：常量必须在构造函数的初始化列表里面初始化或者将其设置为static

正确的程序如下：

Class A

{ A{ const int size=0; }};

或者：

Class A