Chinaunix首页 | 论坛 | 博客
  • 博客访问: 175749
  • 博文数量: 65
  • 博客积分: 1790
  • 博客等级: 上尉
  • 技术积分: 460
  • 用 户 组: 普通用户
  • 注册时间: 2010-09-21 23:51
文章分类
文章存档

2012年(8)

2011年(38)

2010年(19)

C++

分类: C/C++

2011-02-24 23:08:42

试题一:
3.程序输出
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";
char *str8 = "abc";
cout << ( str1 == str2 ) << endl;
cout << ( str3 == str4 ) << endl;
cout << ( str5 == str6 ) << endl;
cout << ( str7 == str8 ) << endl;

4. 代码中的两个sizeof用法有问题吗?
void uppercase( char str[] ) // 将 str 中的小写字母转换成大写字母
{
    for( size_t i=0; i
        if( 'a'<=str[i] && str[i]<='z' )
            str[i] -= ('a'-'A' );
}
char str[] = "abcde";
cout << "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;
uppercase( str );
cout << str << endl;

6.程序输出
int a[5]={1,2,3,4,5};
int *ptr=(int *)(&a+1);
printf("%d,%d\n",*(a+1),*(ptr-1));

7. 有什么问题?
char a;
char *str=&a;
strcpy(str,"hello");
printf(str);


8.有什么问题?
char* s="aaa"; 
printf("%s",s);
s[0]='b';
printf("%s",s);

15. 哪些有编译错误?
int a=248; 
b=4; 
int const c=21; 
const int *d=&a;
int *const e=&b; 
int const *f const =&a;

16. 
交换两个变量的值,不使用第三个变量。即a=3,b=5,交换之后a=5,b=3;


17.有什么问题
#include
#include
void getmemory(char *p)
{
    p=(char *) malloc(100);
    strcpy(p,"hello world");
}
int main( )
{
    char *str=null;
    getmemory(str);
    printf("%s/n",str);
    free(str);
    return 0;
}

28. (void *)ptr 和 (*(void**))ptr的结果是否相同?其中ptr为同一个指针


9.
unsigned char *p1;
unsigned long *p2;
p1=(unsigned char *)0x801000;
p2=(unsigned long *)0x810000;
请问
p1+5=______;
p2+5=______;

2. 以下是求一个数的平方的程序,请找出错误:
#define square(a) ((a)*(a))
int a=5;
int b;
b=square(a++);

1、static全局变量与普通的全局变量有什么区别?static局部变量和普通局部变量有什么区别?static函数与普通函数有什么区别?

2、程序的局部变量存在于()中,全局变量存在于()中,动态申请数据存在于()中。

3、设有以下说明和定义:
typedef union {long i; int k[5]; char c;} date;
struct data { int cat; date cow; double dog;} too;
date max;
则语句printf("%d",sizeof(too)+sizeof(max));的执行结果是:______

7、请找出下面代码中的所有错误
说明:以下代码是把一个字符串倒序,如“abcd”倒序后变为“dcba”
#include "string.h"
main()
{
    char *src="hello,world";
    char* dest=null;
    int len=strlen(src);
    dest=(char*)malloc(len);
    
    char* d=dest;
    char* s=src[len];
    while(len--!=0)
        d++=s--;
    printf("%s",dest);
    return 0;
}

4.运行结果?
#include "stdafx.h"
#define SQR(X) X*X
int main(int argc, char* argv[])
{
 int a = 10;
 int k = 2;
 int m = 1;
 a /= SQR(k+m)/SQR(k+m); 
 printf("%d\n",a); 
 return 0;
}




--------------------------------------------------------------------------
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
  {
   t=a[i];
   a[i]=a[j];
   a[j]=t;
  }
  cout<
}

//第二种
string str;
cin>>str;
str.replace;
cout<

--------------------------------------------------------------------------
3.请简单描述Windows内存管理的方法。
内存管理是操作系统中的重要部分,两三句话恐怕谁也说不清楚吧~~
我先说个大概,希望能够抛砖引玉吧,当程序运行时需要从内存中读出这段程序的代码。代码的位置必须在物理内存中才能被运行,由于现在的操作系统中有非常多的程序运行着,内存中不能够完全放下,所以引出了虚拟内存的概念。把哪些不常用的程序片断就放入虚拟内存,当需要用到它的时候在load入主存(物理内存)中。这个就是内存管理所要做的事。内存管理还有另外一件事需要做:计算程序片段在主存中的物理位置,以便CPU调度。内存管理有块式管理,页式管理,段式和段页式管理。现在常用段页式管理
块式管理:把主存分为一大块、一大块的,当所需的程序片断不在主存时就分配一块主存空间,把程 序片断load入主存,就算所需的程序片度只有几个字节也只能把这一块分配给它。这样会造成很大的浪费,平均浪费了50%的内存空间,但时易于管理。
页式管理:把主存分为一页一页的,每一页的空间要比一块一块的空间小很多,显然这种方法的空间利用率要比块式管理高很多。
段式管理:把主存分为一段一段的,每一段的空间又要比一页一页的空间小很多,这种方法在空间利用率上又比页式管理高很多,但是也有另外一个缺点。一个程序片断可能会被分为几十段,这样很多时间就会被浪费在计算每一段的物理地址上(计算机最耗时间的大家都知道是I/O吧)。
段页式管理:结合了段式管理和页式管理的优点。把主存分为若干页,每一页又分为若干段。好处就很明显,不用我多说了吧。
各种内存管理都有它自己的方法来计算出程序片断在主存中的物理地址,其实都很相似。
这只是一个大概而已,不足以说明内存管理的皮毛。无论哪一本操作系统书上都有详细的讲解

--------------------------------------------------------------------------
4.运行结果?
#include "stdafx.h"
#define SQR(X) X*X
int main(int argc, char* argv[])
{
 int a = 10;
 int k = 2;
 int m = 1;
 a /= SQR(k+m)/SQR(k+m); 
 printf("%d\n",a); 
 return 0;
}
答:
define 只是定义而已,在编择时只是简单代换X*X而已,并不经过算术法则的
a /= (k+m)*(k+m)/(k+m)*(k+m);
=>a /= (k+m)*1*(k+m);
=>a = a/9;
=>a = 1;
PS:经过本人验证,虽然结果一样,但是应该不是这样运算的,应该是a/=k+m*k+m/k+m*k+m;
因为SQR(k+m)/SQR(k+m)的值是7,而不是9。

--------------------------------------------------------------------------
5.
const 符号常量;
(1)const char *p
(2)char const *p
(3)char * const p
说明上面三种描述的区别;


如果const位于星号的左侧,则const就是用来修饰指针所指向的变量,即指针指向为常量;
如果const位于星号的右侧,const就是修饰指针本身,即指针本身是常量。

(1)const char *p

一个指向char类型的const对象指针,p不是常量,我们可以修改p的值,使其指向不同的char,但是不能改变它指向非char对象,如:
const char *p;
char c1='a';
char c2='b';
p=&c1;//ok
p=&c2;//ok
*p=c1;//error

(2)char const *p
(3)char * const p

这两个好象是一样的,此时*p可以修改,而p不能修改。

(4)const char * const p
这种是地址及指向对象都不能修改。

--------------------------------------------------------------------------
6.下面是C语言中两种if语句判断方式。请问哪种写法更好?为什么?
 int n;
 if (n == 10) // 第一种判断方式
 if (10 == n) // 第二种判断方式

如果少了个=号,编译时就会报错,减少了出错的可能行,可以检测出是否少了=

--------------------------------------------------------------------------
7.下面的代码有什么问题?
void DoSomeThing(...)
{
 char* p;
 ...
 p = malloc(1024);  // 分配1K的空间
 if (NULL == p)
  return;
 ...
 p = realloc(p, 2048); // 空间不够,重新分配到2K
 if (NULL == p)
  return;
 ...
}

A:
p = malloc(1024);     应该写成: p = (char *) malloc(1024); 
        没有释放p的空间,造成内存泄漏。


--------------------------------------------------------------------------
8.下面的代码有什么问题?并请给出正确的写法。
void DoSomeThing(char* p)
{
 char str[16];
 int n;
 assert(NULL != p);
 sscanf(p, "%s%d", str, n);
 if (0 == strcmp(str, "something"))
 {
  ...
 }
}

A:
sscanf(p, "%s%d", str, n);   这句该写成: sscanf(p, "%s%d", str, &n);

--------------------------------------------------------------------------
9.下面代码有什么错误?
Void test1() 
 char string[10]; 
 char *str1="0123456789";
 strcpy(string, str1); 

数组越界

--------------------------------------------------------------------------
10.下面代码有什么问题?
Void test2() 
  char string[10], str1[10]; 
  for(i=0; i<10;i++) 
  { 
     str1[i] ='a'; 
  } 
  strcpy(string, str1); 

数组越界

--------------------------------------------------------------------------
11.下面代码有什么问题?
Void test3(char* str1) 
  char string[10]; 
  if(strlen(str1)<=10) 
  { 
    strcpy(string, str1); 
  } 

==数组越界
==strcpy拷贝的结束标志是查找字符串中的\0 因此如果字符串中没有遇到\0的话 会一直复制,直到遇到\0,上面的123都因此产生越界的情况
 
建议使用 strncpy 和 memcpy

--------------------------------------------------------------------------
12.下面代码有什么问题?

#define MAX_SRM 256 

DSN get_SRM_no() 
  static int SRM_no; //是不是这里没赋初值?
  int I; 
  for(I=0;I
  { 
    SRM_no %= MAX_SRM; 
    if(MY_SRM.state==IDLE) 
    { 
      break; 
    } 
  } 
  if(I>=MAX_SRM) 
    return (NULL_SRM); 
  else 
    return SRM_no; 

系统会初始化static int变量为0,但该值会一直保存,所谓的不可重入...

--------------------------------------------------------------------------
13.写出运行结果:
{// test1
    char str[] = "world"; cout << sizeof(str) << ": ";
    char *p    = str;     cout << sizeof(p) << ": ";
    char i     = 10;      cout << sizeof(i) << ": ";
    void *pp   = malloc(10);  cout << sizeof(p) << endl;
}

6:4:1:4

--------------------------------------------------------------------------
14.写出运行结果:
{// test2
    union V {
 struct X {
  unsigned char s1:2;
  unsigned char s2:3;
  unsigned char s3:3;
 } x;
;unsigned char c;
    } v;

    v.c = 100;
    printf("%d", v.x.s3); 

}

3

--------------------------------------------------------------------------
15.用C++写个程序,如何判断一个操作系统是16位还是32位的?不能用sizeof()函数

A1:
16位的系统下,
int i = 65536;
cout << i; // 输出0;
int i = 65535;
cout << i; // 输出-1;

32位的系统下,
int i = 65536;
cout << i; // 输出65536;
int i = 65535;
cout << i; // 输出65535;

A2:

int a = ~0;
if( a>65536 ) 
{
    cout<<"32 bit"<
}
else
{
    cout<<"16 bit"<
}


--------------------------------------------------------------------------
16.C和C++有什么不同?

从机制上:c是面向过程的(但c也可以编写面向对象的程序);c++是面向对象的,提供了类。但是,
c++编写面向对象的程序比c容易

从适用的方向:c适合要求代码体积小的,效率高的场合,如嵌入式;c++适合更上层的,复杂的;  llinux核心大部分是c写的,因为它是系统软件,效率要求极高。

从名称上也可以看出,c++比c多了+,说明c++是c的超集;那为什么不叫c+而叫c++呢,是因为c++比
c来说扩充的东西太多了,所以就在c后面放上两个+;于是就成了c++

C语言是结构化编程语言,C++是面向对象编程语言。
C++侧重于对象而不是过程,侧重于类的设计而不是逻辑的设计。

--------------------------------------------------------------------------
17.在不用第三方参数的情况下,交换两个参数的值
#include

void main()
{
        int i=60;
        int j=50;
        i=i+j;
        j=i-j;
        i=i-j;
        printf("i=%d\n",i);
        printf("j=%d\n",j);
}

方法二:
i^=j;
j^=i;
i^=j;

方法三:
// 用加减实现,而且不会溢出
a = a+b-(b=a)

--------------------------------------------------------------------------
18.有关位域的面试题(为什么输出的是一个奇怪的字符)

a.t = 'b';效果相当于 a.t= 'b' & 0xf;

'b' --> 01100010
'b' & 0xf -->>00000010
所以输出Ascii码为2的特殊字符


char t:4;就是4bit的字符变量,同样
unsigned short i:8;就是8bit的无符号短整形变量

--------------------------------------------------------------------------
19.int i=10, j=10, k=3; k*=i+j; k最后的值是?

60

--------------------------------------------------------------------------
20.进程间通信的方式有?

进程间通信的方式有 共享内存, 管道 ,Socket ,消息队列 , DDE等

--------------------------------------------------------------------------

21.
struct A 
char t:4; 
char k:4; 
unsigned short i:8; 
unsigned long m; 
sizeof(A)=?(不考虑边界对齐) 

7

PS:我用TC运算了一遍,结果是6,至于为什么答案是7还是没有想通,待续。。。


struct CELL             // Declare CELL bit field
{
   unsigned character  : 8;  // 00000000 ????????
   unsigned foreground : 3;  // 00000??? 00000000
   unsigned intensity  : 1;  // 0000?000 00000000
   unsigned background : 3;  // 0???0000 00000000
   unsigned blink      : 1;  // ?0000000 00000000
} screen[25][80];       // Array of bit fields
二、位结构 
    位结构是一种特殊的结构, 在需按位访问一个字节或字的多个位时, 位结构 
比按位运算符更加方便。 
    位结构定义的一般形式为: 
     struct位结构名{ 
          数据类型 变量名: 整型常数; 
          数据类型 变量名: 整型常数; 
     } 位结构变量; 
    其中: 数据类型必须是int(unsigned或signed)。 整型常数必须是非负的整 
数, 范围是0~15, 表示二进制位的个数, 即表示有多少位。 
    变量名是选择项, 可以不命名, 这样规定是为了排列需要。 
    例如: 下面定义了一个位结构。 
     struct{ 
          unsigned incon: 8;  /*incon占用低字节的0~7共8位*/ 
          unsigned txcolor: 4;/*txcolor占用高字节的0~3位共4位*/ 
          unsigned bgcolor: 3;/*bgcolor占用高字节的4~6位共3位*/ 
          unsigned blink: 1;  /*blink占用高字节的第7位*/ 
     }ch; 
    位结构成员的访问与结构成员的访问相同。 
    例如: 访问上例位结构中的bgcolor成员可写成: 
      ch.bgcolor 
  
    注意: 
    1. 位结构中的成员可以定义为unsigned, 也可定义为signed,  但当成员长 
度为1时, 会被认为是unsigned类型。因为单个位不可能具有符号。 
    2. 位结构中的成员不能使用数组和指针, 但位结构变量可以是数组和指针, 
如果是指针, 其成员访问方式同结构指针。 
    3. 位结构总长度(位数), 是各个位成员定义的位数之和,  可以超过两个字 
节。 
    4. 位结构成员可以与其它结构成员一起使用。 
    例如: 
     struct info{ 
          char name[8]; 
          int age; 
          struct addr address; 
          float pay; 
          unsigned state: 1; 
          unsigned pay: 1; 
          }workers;
    上例的结构定义了关于一个工人的信息。其中有两个位结构成员, 每个位结 
构成员只有一位, 因此只占一个字节但保存了两个信息, 该字节中第一位表示工 
人的状态, 第二位表示工资是否已发放。由此可见使用位结构可以节省存贮空间。


--------------------------------------------------------------------------
22.下面的函数实现在一个固定的数上加上一个数,有什么错误,改正 
int add_n(int n) 
  static int i=100; 
  i+=n; 
  return i; 

答:
因为static使得i的值会保留上次的值。
去掉static就可了

--------------------------------------------------------------------------
23.下面的代码有什么问题?
class A 
public: 
  A() { p=this; } 
  ~A() { if(p!=NULL) { delete p; p=NULL; } } 

  A* p; 
};

答:
会引起无限递归

--------------------------------------------------------------------------
24.
union a {
 int a_int1;
 double a_double;
 int a_int2;
};

typedef struct
{
 a a1;
 char y;
} b;

class c
{
 double c_double;
 b b1;
 a a2;

};

输出cout<

答:
VC6环境下得出的结果是32

另:
我(sun)在VC6.0+win2k下做过试验:
short - 2
int-4
float-4
double-8
指针-4

sizeof(union),以结构里面size最大的为union的size

 ----------------------------------------------------------------------------------

25.i最后等于多少?
int i = 1;
int j = i++;
if((i>j++) && (i++ == j)) i+=j;

答:
i = 5

--------------------------------------------------------------------------
26.
unsigned short array[]={1,2,3,4,5,6,7};
int i = 3 

;
*(array + i) = ?

答:
4

--------------------------------------------------------------------------
27.
class A
{
  virtual void func1();
  void func2();
}
Class B: class A
{
  void func1(){cout << "fun1 in class B" << endl;}
  virtual void func2(){cout << "fun2 in class B" << endl;}
A, A中的func1和B中的func2都是虚函数.
B, A中的func1和B中的func2都不是虚函数.
C, A中的func2是虚函数.,B中的func1不是虚函数.
D, A中的func2不是虚函数,B中的func1是虚函数.

答:
A

--------------------------------------------------------------------------
28.
数据库:抽出部门,平均工资,要求按部门的字符串顺序排序,不能含有"human resource"部门, 

employee结构如下:employee_id, employee_name, depart_id,depart_name,wage

答:
select depart_name, avg(wage)
from employee
where depart_name <> 'human resource'
group by depart_name
order by depart_name

--------------------------------------------------------------------------
29.
给定如下SQL数据库:Test(num INT(4)) 请用一条SQL语句返回num的最小值,但不许使用统计功能,如MIN,MAX等

答:
select top 1 num
from Test
order by num desc

--------------------------------------------------------------------------
30.
输出下面程序结果。 

#include  

class A 
public:
 virtual void print(void) 
 { 
    cout<<"A::print()"<
 } 
};
class B:public A 
public:
 virtual void print(void) 
 { 
   cout<<"B::print()"<
 }; 
}; 
class C:public B
{
public:
 virtual void print(void)
 {
  cout<<"C::print()"<
 }
};
void print(A a) 
   a.print(); 
void main(void) 
   A a, *pa,*pb,*pc; 
   B b; 
   C c; 
   
   pa=&a; 
   pb=&b; 
   pc=&c; 
   
   a.print(); 
   b.print(); 
   c.print(); 
   
   pa->print(); 
   pb->print(); 
   pc->print(); 
   
   print(a); 
   print(b); 
   print(c); 
}

A:
A::print()
B::print()
C::print()
A::print()
B::print()
C::print()
A::print()
A::print()
A::print()

--------------------------------------------------------------------------
31.
试编写函数判断计算机的字节存储顺序是开序(little endian)还是降序(bigendian)

答:
bool IsBigendian()
{
 unsigned short usData = 0x1122;
 unsigned char  *pucData = (unsigned char*)&usData;

 return (*pucData == 0x22);
}

--------------------------------------------------------------------------
32.简述Critical Section和Mutex的不同点

答:
对几种同步对象的总结
1.Critical Section
A.速度快
B.不能用于不同进程
C.不能进行资源统计(每次只可以有一个线程对共享资源进行存取)

2.Mutex
A.速度慢
B.可用于不同进程
C.不能进行资源统计

3.Semaphore
A.速度慢
B.可用于不同进程
C.可进行资源统计(可以让一个或超过一个线程对共享资源进行存取)

4.Event
A.速度慢
B.可用于不同进程
C.可进行资源统计

 

--------------------------------------------------------------------------
33.一个数据库中有两个表:
一张表为Customer,含字段ID,Name;
一张表为Order,含字段ID,CustomerID(连向Customer中ID的外键),Revenue;
写出求每个Customer的Revenue总和的SQL语句。

建表
create table customer
(
ID int primary key,Name char(10)
)

go

create table [order]
(
ID int primary key,CustomerID  int foreign key references customer(id) , Revenue float
)

go

--查询
select Customer.ID, sum( isnull([Order].Revenue,0) )
from customer full join [order] 
on( [order].customerid=customer.id )
group by customer.id

--------------------------------------------------------------------------
34.请指出下列程序中的错误并且修改
void GetMemory(char *p){
  p=(char *)malloc(100);
}
void Test(void){
  char *str=NULL;
  GetMemory=(str);
  strcpy(str,"hello world");
  printf(str);
}

A:错误--参数的值改变后,不会传回
GetMemory并不能传递动态内存,Test函数中的 str一直都是 NULL。
strcpy(str, "hello world");将使程序崩溃。

修改如下:
char *GetMemory(){
  char *p=(char *)malloc(100);
  return p;
}
void Test(void){
  char *str=NULL;
  str=GetMemory(){
  strcpy(str,"hello world");
  printf(str);
}

方法二:void GetMemory2(char **p)变为二级指针.
void GetMemory2(char **p, int num)
{
 *p = (char *)malloc(sizeof(char) * num);
}

--------------------------------------------------------------------------
35.程序改错
class mml
{
  private:
    static unsigned int x;
  public:
    mml(){ x++; }
    mml(static unsigned int &) {x++;}
    ~mml{x--;}
  pulic:
    virtual mon() {} = 0;
    static unsigned int mmc(){return x;}
    ......                      
 
};
class nnl:public mml
{
  private:
    static unsigned int y;
  public:
    nnl(){ x++; }
    nnl(static unsigned int &) {x++;}
    ~nnl{x--;}
  public:
    virtual mon() {};
     static unsigned int nnc(){return y;}
    ......                   
};

代码片断:
mml* pp = new nnl;
..........
delete pp;


A:
基类的析构函数应该为虚函数
virtual ~mml{x--;}

--------------------------------------------------------------------------
36.101个硬币100真、1假,真假区别在于重量。请用无砝码天平称两次给出真币重还是假币重的结论。

答:
101个先取出2堆,
33,33
第一次称,如果不相等,说明有一堆重或轻
那么把重的那堆拿下来,再放另外35个中的33
如果相等,说明假的重,如果不相等,新放上去的还是重的话,说明假的轻(不可能新放上去的轻)

第一次称,如果相等的话,这66个肯定都是真的,从这66个中取出35个来,与剩下的没称过的35个比
下面就不用说了

方法二:
第3题也可以拿A(50),B(50)比一下,一样的话拿剩下的一个和真的比一下。
如果不一样,就拿其中的一堆。比如A(50)再分成两堆25比一下,一样的话就在
B(50)中,不一样就在A(50)中,结合第一次的结果就知道了。

--------------------------------------------------------------------------
37.static变量和static 函数各有什么特点?

答:
static变量:在程序运行期内一直有效,如果定义在函数外,则在编译单元内可见,如果在函数内,在在定义的block内可见;
static函数:在编译单元内可见;

--------------------------------------------------------------------------
38.用C 写一个输入的整数,倒着输出整数的函数,要求用递归方法 ;

答:
void fun( int a )
{
 printf( "%d", a%10 );
 a /= 10;
 if( a <=0 )return;

 fun( a );
}

--------------------------------------------------------------------------
39.写出程序结果:
void Func(char str[100])
{
  printf("%d\n", sizeof(str));
}

答:
4
分析:
指针长度

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

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




(一) 初级题
1. 什么是预编译,何时需要预编译?
答:
(1) 总是使用不经常改动的大型代码体
(2) 程序由多个模块组成,所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下,可以将所有包含文件预编译为一个预编译头

2. 
char * const p
char const * p
const char *p
上述三个有什么区别?
答:
(1) 常量指针,p的值不可以修改
(2) 指向常量的指针,指向的常量值不可以改
(3) 同(2)

3.
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";
char *str8 = "abc";
cout << ( str1 == str2 ) << endl;
cout << ( str3 == str4 ) << endl;
cout << ( str5 == str6 ) << endl;
cout << ( str7 == str8 ) << endl;
答:
0 0 1 1
str1,str2,str3,str4是数组变量,它们有各自的内存空间;而str5,str6,str7,str8是指针,它们指向相同的常量区域。

4. 
以下代码中的两个sizeof用法有问题吗?
void uppercase( char str[] ) // 将 str 中的小写字母转换成大写字母
{
    for( size_t i=0; i
        if( 'a'<=str[i] && str[i]<='z' )
            str[i] -= ('a'-'A' );
}
char str[] = "abcde";
cout << "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;
uppercase( str );
cout << str << endl;
答:函数内的sizeof有问题。根据语法,sizeof如用于数组,只能测出静态数组的大小,无法检测动态分配的或外部数组大小。函数外的str是一个静态定义的数组,因此其大小为6,因为还有'\0',函数内的str实际只是一个指向字符串的指针,没有任何额外的与数组相关的信息,因此sizeof作用于上只将其当指针看,一个指针为4个字节,因此返回4。

5. 
一个32位的机器,该机器的指针是多少位
答:指针是多少位只要看地址总线的位数就行了。80386以后的机子都是32的数据总线。所以指针的位数就是4个字节了。

6.
main()
{
   int a[5]={1,2,3,4,5};
   int *ptr=(int *)(&a+1);
   printf("%d,%d\n",*(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]。

7. 请问以下代码有什么问题?
char a;
char *str=&a;
strcpy(str,"hello");
printf(str);

答:没有为str分配内存空间,将会发生异常。问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果,但因为越界进行内在读写而导致程序崩溃。

8.
char* s="aaa"; 
printf("%s",s);
s[0]='b';
printf("%s",s);
有什么问题?
答:"aaa"是字符串常量。s是指针,指向这个字符串常量,所以声明s的时候就有问题。
cosnt char* s="aaa"; 然后又因为是常量,所以对是s[0]的赋值操作是不合法的。

9. 写一个“标准”宏,这个宏输入两个参数并返回较小的一个。
答:#define min(x, y) ((x)>(y)?(y)x)) //结尾没有';'

10. 嵌入式系统中经常要用到无限循环,你怎么用c编写死循环。
答:while(1){}或者for(;;)

11. 关键字static的作用是什么?
答:定义静态变量

12. 关键字const有什么含意?
答:表示常量不可以修改的变量。

13. 关键字volatile有什么含意?并举出三个不同的例子?
答:提示编译器对象的值可能在编译器未监测到的情况下改变。

14. int (*s[10])(int) 表示的是什么啊?
答:int (*s[10])(int) 函数指针数组,每个指针指向一个int func(int param)的函数。

15. 请问下列表达式哪些会被编译器禁止?为什么?
int a=248; 
b=4; 
int const c=21; 
const int *d=&a;
int *const e=&b; 
int const *f const =&a;
答:
b=4;     => int b=4;
int const *f const=&a;    => int const *const f=&a;

16. 
交换两个变量的值,不使用第三个变量。即a=3,b=5,交换之后a=5,b=3;
答:有两种解法, 一种用算术算法, 一种用^(异或)
a = a + b;
b = a - b;
a = a - b;
or
a = a^b;// 只能对int,char..
b = a^b;
a = a^b;
or
a ^= b ^= a;

17.有什么问题
#include
#include
void getmemory(char *p)
{
    p=(char *) malloc(100);
    strcpy(p,"hello world");
}
int main( )
{
    char *str=null;
    getmemory(str);
    printf("%s/n",str);
    free(str);
    return 0;
}
答:程序崩溃,getmemory中的malloc 不能返回动态内存, free()对str操作很危险

18. 列举几种进程的同步机制,并比较其优缺点。
答:原子操作、信号量机制、自旋锁、管程、会合、分布式系统

20. 进程之间通信的途径
答:共享存储系统、消息传递系统、管道:以文件系统为基础

21. 进程死锁的原因和4个必要条件
答:资源竞争及进程推进顺序非法;互斥、请求保持、不可剥夺、环路

22. 死锁的处理
答:鸵鸟策略、预防策略、避免策略、检测与解除死锁

23. 操作系统中进程调度策略有哪几种?
答:fcfs(先来先服务),优先级,时间片轮转,多级反馈

24. 类的静态成员和非静态成员有何区别?
答:类的静态成员每个类只有一个,非静态成员每个对象一个

25. 纯虚函数如何定义?使用时应注意什么?
答:virtual void f()=0; 是接口,子类必须要实现

26. 数组和链表的区别
答:
数组:数据顺序存储,固定大小
链表:数据可以随机存储,大小可动态改变

27. iso的七层模型是什么?tcp/udp是属于哪一层?tcp/udp有何优缺点?
答:应用层、表示层、会话层、传输层、网络层、物理链路层、物理层
tcp/udp属于运输层
tcp服务提供了数据流传输、可靠性、有效流控制、全双工操作和多路复用技术等。
与tcp 不同, udp并不提供对ip协议的可靠机制、流控制以及错误恢复功能等。由于udp比较简单,udp头包含很少的字节,比tcp负载消耗少
tcp: 提供稳定的传输服务,有流量控制,缺点是包头大,冗余性不好
udp: 不提供稳定的服务,包头小,开销小 

28. (void *)ptr 和 (*(void**))ptr的结果是否相同?其中ptr为同一个指针
答:(void *)ptr 和 (*(void**))ptr值是相同的
 
29.
int main()
{
    int x=3;
    printf("%d",x);
    return 1;
}
问函数既然不会被其它函数调用,为什么要返回1?
答:main中,c标准认为0表示成功,非0表示错误。具体的值是某中具体出错信息

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

31. 已知一个数组table,用一个宏定义,求出数据的元素个数
答:
#define ntbl
#define ntbl (sizeof(table)/sizeof(table[0]))

32. 线程与进程的区别和联系? 线程是否具有相同的堆栈? dll是否有独立的堆栈?
答:进程是死的,只是一些资源的集合,真正的程序执行都是线程来完成的,程序启动的时候操作系统就帮你创建了一个主线程。每个线程有自己的堆栈。dll中有没有独立的堆栈,这个问题不好回答,或者说这个问题本身是否有问题。因为dll中的代码是被某些线程所执行,只有线程拥有堆栈,如果dll中的代码是exe中的线程所调用,那么这个时候是不是说这个dll没有自己独立的堆栈?如果dll中的代码是由dll自己创建的线程所执行,那么是不是说dll有独立的堆栈?
以上讲的是堆栈,如果对于堆来说,每个dll有自己的堆,所以如果是从dll中动态分配的内存,最好是从dll中删除,如果你从dll中分配内存,然后在exe中,或者另外一个dll中删除,很有可能导致程序崩溃

33. 
unsigned short a = 10;
printf("~a = %u\n", ~a);
char c=128;
printf("c = %d\n",c);
输出多少?并分析过程
答:
第一题,~a =0xfffffff5, int值为-11,但输出的是uint。所以输出4294967285。
第二题,c=0x10,输出的是int,最高位为1,是负数,所以它的值就是0x00的补码就是128,所以输出-128。
这两道题都是在考察二进制向int或uint转换时的最高位处理。
 

(二) 中级题
1. -1,2,7,28,,126请问28和126中间那个数是什么?为什么?
答:
第一题应该是4^3-1=63
规律是n^3-1(当n为偶数0,2,4)
      n^3+1(当n为奇数1,3,5)
      
2. 用两个栈实现一个队列的功能?要求给出算法和思路!
答:设2个栈为a,b, 一开始均为空.
入队:
将新元素push入栈a;
出队:
(1)判断栈b是否为空;
(2)如果不为空,则将栈a中所有元素依次pop出并push到栈b;
(3)将栈b的栈顶元素pop出;
这样实现的队列入队和出队的平摊复杂度都还是o(1), 比上面的几种方法要好。

3. 在c语言库函数中将一个字符转换成整型的函数是atol()吗,这个函数的原型是什么?
答:
函数名: atol
功  能: 把字符串转换成长整型数
用  法: long atol(const char *nptr);
程序例:
#include
#include
int main(void)
{
   long l;
   char *str = "98765432";
   l = atol(lstr);
   
   printf("string = %s integer = %ld\n", str, l);
   return(0);
}

4. 对于一个频繁使用的短小函数,在c语言中应用什么实现,在c++中应用什么实现?
答:c用宏定义,c++用inline

5. 直接链接两个信令点的一组链路称作什么?
答:ppp点到点连接

7. 软件测试都有那些种类?
答:黑盒:针对系统功能的测试    白合:测试函数功能,各函数接口

8. 确定模块的功能和模块的接口是在软件设计的那个阶段完成的?
答:概要设计阶段

9.
unsigned char *p1;
unsigned long *p2;
p1=(unsigned char *)0x801000;
p2=(unsigned long *)0x810000;
请问
p1+5=______;
p2+5=______;
答案:801005;810014。不要忘记了这个是16进制的数字,p2要加20变为16进制就是14

选择题:
1. ethternet链接到internet用到以下那个协议?
a.hdlc;  b.arp;  c.udp;  d.tcp;  e.ip


2. 属于网络层协议的是:
a.tcp;  b.ip;  c.icmp;  d.x.25
答:b,c

3.windows消息调度机制是:
a.指令队列;  b.指令堆栈;  c.消息队列;  d.消息堆栈;
答:b,a,c

找错题:

1. 有什么错误?
int a[60][250][1000],i,j,k;
for(k=0;k<=1000;k++)
    for(j=0;j<250;j++)
        for(i=0;i<60;i++)
            a[i][j][k]=0;

答:把循环语句内外换一下
 
2. 以下是求一个数的平方的程序,请找出错误:
#define square(a) ((a)*(a))
int a=5;
int b;
b=square(a++);
答案:这个没有问题,s(a++),就是((a++)×(a++))唯一要注意的就是计算后a=7了
 
3. 找错误
typedef unsigned char byte
int examply_fun(byte gt_len; byte *gt_code)
{
    byte *gt_buf;
    gt_buf=(byte *)malloc(max_gt_length);
    
    if(gt_len>max_gt_length)
    {
        return gt_length_error; 
    }
}
答:要释放内存

问答题:
1.ip phone的原理是什么?
答:ipv6

2.tcp/ip通信建立的过程怎样,端口有什么作用?
答:三次握手,确定是哪个应用程序使用该协议
 
(三) 高级题
1、static全局变量与普通的全局变量有什么区别?static局部变量和普通局部变量有什么区别?static函数与普通函数有什么区别?
答:全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式, 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序, 当一个源程序由多个源文件组成时,非静态的全局变量在各个源文件中都是有效的。
而静态全局变量则限制了其作用域, 即只在定义该变量的源文件内有效, 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内,只能为该源文件内的函数公用, 因此可以避免在其它源文件中引起错误。从以上分析可以看出, 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域, 限制了它的使用范围。
static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static),内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数,应该在一个头文件中说明,要使用这些函数的源文件要包含这个头文件
static全局变量与普通的全局变量有什么区别:static全局变量只初使化一次,防止在其他文件单元中被引用;
static局部变量和普通局部变量有什么区别:static局部变量只被初始化一次,下一次依据上一次结果值;
static函数与普通函数有什么区别:static函数在内存中只有一份,普通函数在每个被调用中维持一份拷贝

2、程序的局部变量存在于()中,全局变量存在于()中,动态申请数据存在于()中。
答:栈;静态区;堆

3、设有以下说明和定义:
typedef union {long i; int k[5]; char c;} date;
struct data { int cat; date cow; double dog;} too;
date max;
则语句printf("%d",sizeof(too)+sizeof(max));的执行结果是:______

答:date是一个union, 变量公用空间. 里面最大的变量类型是int[5], 占用20个字节. 所以它的大小是20
data是一个struct, 每个变量分开占用空间. 依次为int4 + date20 + double8 = 32.
所以结果是 20 + 32 = 52.
当然...在某些16位编辑器下, int可能是2字节,那么结果是 int2 + date10 + double8 = 20

4、队列和栈有什么区别?
答:队列先进先出,栈后进先出÷

5、已知一个单向链表的头,请写出删除其某一个结点的算法,要求,先找到此结点,然后删除。
答:
slnodetype *delete(slnodetype *head,int key)
{
    if(head->number==key)
    {
        head=pointer->next;
        free(pointer);
        break;
    }
    
    back = pointer;
    pointer=pointer->next;
    
    if(pointer->number==key)
    {
        back->next=pointer->next;
        free(pointer);
        break;
    }
    
    void delete(node* p)
    {
        if(head = node)
            while(p)
    }
}
 
7、请找出下面代码中的所有错误
说明:以下代码是把一个字符串倒序,如“abcd”倒序后变为“dcba”
#include "string.h"
main()
{
    char *src="hello,world";
    char* dest=null;
    int len=strlen(src);
    dest=(char*)malloc(len);
    
    char* d=dest;
    char* s=src[len];
    while(len--!=0)
        d++=s--;
    printf("%s",dest);
    return 0;
}

答:还要加上#include

int main()
{
    char* src = "hello,world";
    int len = strlen(src);
    char* dest = (char*)malloc((len+1)*sizeof(char)); //要为\0分配一个空间
    char* d = dest;
    char* s = src[len-1]; //指向最后一个字符
    while( len-- != 0 )
        *d++=*s--;
    *d = 0; //尾部要加\0
    printf("%s\n",dest);
    free(dest);// 使用完,应当释放空间,以免造成内存汇泄露
    return 0;
}



高质量C++编程指南:

1,零值比较
if(n==0) if(n!=0)

if(!flag) if(flag)
    
if((abs(x-0))<0.00000001) if((abs(x-0))>0.00000001)
    
if(p==NULL) if(p!=NULL)

2,
char str[]="hello";
char *p=str;
int n=10;
sizeof(str)=6
sizeof(p)=4
sizeof(n)=4
vod Func(char str[100]){
    sizeof(str)=4
}
void *p=malloc(100);
sizeof(p)=4

4,
void test(int x,int y)
C编译后符号库中名字为_test,而C++编译器产生像_test_int_int之类的名字。

四、
hello worldasdfasdfsdfasdfasdf
hello world

函数不可返回指向栈内存的指针或引用,该内存在函数结束时被自动摧毁。
char *Func(void){
    char str[] = "hello world";//str的内存位于栈内
    ...
    return str;
}
使用return temp(s1+s2),而不用
string temp(s1+s2)
return temp
函数不要带有记忆功能,相同输入应产生相同输出。
static局部变量是函数的记忆存储器,尽量少用static局部变量。
断言asset是仅在debug版本起作用的宏。
数组内容复制和比较
数组,不能用b=a复制,b==a比较,使用strcpy复制,使用strcmp比较
指针,不能用p=a复制,p==a比较,使用strcpy复制,使用strcmp
比较
数组作为函数参数传递时,数组自动退化为同类型的指针
函数参数是一个指针,不要指望用指针去申请动态内存
malloc/free是C语言标准库函数,new/delete是C++的运算符。不能把执行构造函数和析构函数的任务强加于malloc/free。

重载:同一类,名字相同,参数不同
覆盖:父子类,名字相同,参数相同,有virtual
1)父子类,名字相同,参数不同,基类函数被隐藏。(非重载)区别在于同一类还是父子类。
2)父子类,名字相同,参数相同,基类函数无virtual,基类函数被隐藏。(非覆盖)区别在于是否有virtual。
参数缺省值出现在函数的声明中,不能出现在函数的定义体中。
inline必须与函数定义体放在一起才能使函数成为内联。仅将inline放在函数声明前不起作用。
声明和定义不可混为一谈,用户没有必要,也不应该知道函数是否需要内联。
定义数组的同时必须初始化数组,使用free或delete释放内存后,没有将指针设置为NULL,产生野指针。
解决:对象初始化工作放在构造函数中,清除工作放在析构函数中。当对象被创建时,构造函数自动执行,当对象消亡时,析构函数自动执行。
这样就不用担心对象的初始化和清除工作。
构造函数初始化表执行发生在函数体内的任何代码执行之前。
1,类存在继承关系,派生类必须在初始化表里调用基类的构造函数。
2,类的const变量只能在初始化表里被初始化,因为它不能在函数体内用赋值的方式初始化。
3,非内部数据成员对象应当采用初始化表方式初始化,以获取更高的效率。
对于内部数据类型的数据成员而言,两种初始化方式的效率几乎一样,建议用构造函数体内赋值的方式。
成员对象初始化的次序完全不受在初始化表中次序的影响,由在类中声明的次序决定。
拷贝构造函数与赋值函数
如果不主动编写拷贝构造函数和赋值函数,编译器以位拷贝的方式自动生成缺省函数。如类中含有指针,2个缺省将隐含着错误。
拷贝构造函数是在对象被创建时调用,赋值函数只能被已经存在的对象调用。
string a("hello");
string a("world");
string c=a;//拷贝构造函数
c=a;//赋值函数
派生类的构造函数应在初始化表里调用基类的构造函数
基类与派生类的析构函数应该为虚。
编写派生类赋值函数时,也要对基类数据成员重新赋值。
Base::operate =(other);
constructor destructor assignment

const constant
输入参数采用值传递,函数将自动产生临时变量用于复制参数,输入参数无需保护,不要加const。
void Func1(int x)不要写为void Func1(const int x)
void Func2(A a)不要写为void Func2(const A a),形参要赋值对象A,函数效率低
传引用void Func3(B &b)要写为void Func3(const B &b)
对于非内部数据类型输入参数,应该将值传递方式改为const引用传递,提高执行效率。
对于内部数据类型的输入参数,不要将值传递该为const引用传递,不会提高效率。


程序效率
时间效率指执行速度,空间效率指占用内存或外存状况。
紧凑的代码未必产生高效的机器码。
尽量使用显示数据类型初始化,避免让编译器进行隐式数据类型转换。
指针传递方式,函数返回值加const修饰,函数返回值内容不能被修改。
const char* getString(void);//返回指针不能被修改
const char *str=getString();//返回指针赋值为const类型指针
值传递方式,函数会把返回值复制到外部临时存储单元,加const无任何意义。
const成员函数,任何不修改数据成员的函数都应声明为const类型。const放在函数最后。
int getCount(void) const;//const成员函数

void getMemory(char *p, int num)
{
    p=(char *)malloc(sizeof(char)*num);
}
void test(void)
{
    char *str=NULL;
    getMemory(str,100);//str仍然为NULL
    strcpy(str,"hello");//运行错误
}
编译器为每个函数参数制作一个副本,指针参数p的副本是_p,编译器使_p=p,
如果函数体内的程序修改了_p的内容,导致参数p的内容作相应修改。这即是指针用作输出参数的原因。
本例中,_p申请了新内存,只是把_p所指的内存地址改变了,但是p丝毫未变。

char *getString(void)
{
    char p[]="hello world";
    return p;
}
void test4(void)
{
    char *str=NULL;
    str=getString();//str的内容是垃圾
    cout<
}
return语句返回栈内存,栈内存在函数返回时自动消亡。

char *getMemory3(int num)
{
    char *p=(char *)malloc(sizeof(char)*num);
    return p;
}
void test3(void)
{
    char *str=NULL;
    str=getMemory3(100);
    strcpy(str,"hello");
    cout<
    free(str);
}

char *p=(char *)malloc(100);
strcpy(p,"hello");
free(p);
if(p!=NULL)
{
    strcpy(p,"world");//出错
}

char *getString2(void){
char *p ="hello world";
return p}
void test5(void){
char *str=NULL;
str=getString2();
cout<
}

C++问答:
1,vc6.0中无法使用cout输出string类型变量的解决办法 http://hi.baidu.com/ruisen/blog/item/6f157b435a2c97129213c66b.html
答:vc6.0中无法使用cout输出string类型变量的解决办法:
其实,这个问题的出现完全是应为你自己不老实。在多数的教程上会教你用
#include
#include
但你若使用了
#include
#include
的话,问题就会出现了。至于为什么,我也不是很清楚,大家可以查看CSDN中的帮助:
http://blog.csdn.net/gengxt2003/archive/2007/06/07/1642236.aspx
这个问题对我们这些新手来说可能是十分头痛的,但如果你按照教程上的方法来编写代码的话也许就不会出现这个问题了。虽然大家不一定都会遇到,但发出来还是希望对那些遇到了这个问题的朋友有所帮助。

2,CString,int,string,char*之间的转换 http://hi.baidu.com/tiemsn/blog/item/f5ff86d6eae1602e06088b71.html
1 CString,int,string,char*之间的转换  
string 转 CString  
CString.format("%s", string.c_str());  
char 转 CString  
CString.format("%s", char*);  
char 转 string  
string s(char *);  
string 转 char *  
char *p = string.c_str();  
CString 转 string  
string s(CString.GetBuffer());  
1,string -> CString  
CString.format("%s", string.c_str());  
用c_str()确实比data()要好.  
2,char -> string  
string s(char *);  
你的只能初始化,在不是初始化的地方最好还是用assign().  
3,CString -> string  
string s(CString.GetBuffer());  
GetBuffer()后一定要ReleaseBuffer(),否则就没有释放缓冲区所占的空间.  
《C++标准函数库》中说的  
有三个函数可以将字符串的内容转换为字符数组和C—string  
1.data(),返回没有”\0“的字符串数组  
2,c_str(),返回有”\0“的字符串数组  
3,copy()  
CString互转int  
将字符转换为整数,可以使用atoi、_atoi64或atol。  
而将数字转换为CString变量,可以使用CString的Format函数。如  
CString s;  
int i = 64;  
s.Format("%d", i)  
Format函数的功能很强,值得你研究一下。  
void CStrDlg::OnButton1()  
{  
// TODO: Add your control notification handler code here  
CString  
ss="1212.12";  
int temp=atoi(ss);  
CString aa;  
aa.Format("%d",temp);  
AfxMessageBox("var is " + aa);  
}  
sart.Format("%s",buf);  
CString互转char*  
///char * TO cstring  
CString strtest;  
char * charpoint;  
charpoint="give string a value";  
strtest=charpoint;  
///cstring TO char *  
charpoint=strtest.GetBuffer(strtest.GetLength());  
标准C里没有string,char *==char []==string  
可以用CString.Format("%s",char *)这个方法来将char *转成CString。要把CString转成char *,用操作符(LPCSTR)CString就可以了。  
CString转换 char[100]  
char a[100];  
CString str("aaaaaa");  
strncpy(a,(LPCTSTR)str,sizeof(a));  
2 CString类型的转换成int  
CString类型的转换成int  
将字符转换为整数,可以使用atoi、_atoi64或atol。  
//CString aaa = "16" ; 
//int int_chage = atoi((lpcstr)aaa) ;  
而将数字转换为CString变量,可以使用CString的Format函数。如  
CString s;  
int i = 64;  
s.Format("%d", i)  
Format函数的功能很强,值得你研究一下。  
如果是使用char数组,也可以使用sprintf函数。 
//CString ss="1212.12";  
//int temp=atoi(ss);  
//CString aa;  
//aa.Format("%d",temp);  
数字->字符串除了用CString::Format,还有FormatV、sprintf和不需要借助于Afx的itoa  
3 char* 在装int  
#include  
int atoi(const char *nptr); 
long atol(const char *nptr); 
long long atoll(const char *nptr); 
long long atoq(const char *nptr);  
4 CString,int,string,char*之间的转换  
string aa("aaa"); 
char *c=aa.c_str(); 
cannot convert from 'const char *' to 'char *' 
const char *c=aa.c_str();  
5 CString,int,string,char*之间的转换  
string.c_str()只能转换成const char *, 
要转成char *这样写: 
string mngName; 
char t[200]; memset(t,0,200); strcpy(t,mngName.c_str()); 





ESP,Embeded Systems Programming C语言

预处理器Preprocessor

1,预处理指令声明一个常量

#define SECONDS_PER_YEARS (60*60*24*365)UL

2,写一个标准宏MIN,输入2个参数返回最小值

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

3,死循环Infinite loops

while(1){}

或者

Loop:

go Loop;

4,数据声明Data declarations

int a;//An integer

int *a;//A pointer to an integer

int **a;//A pointer to a pointer to an integer

int a[10];//An array of 10 integers

int *a[10];//An array of 10 pointers to integers

int (*a)[10];//A pointer to an array of 10 integers

int (*a)(int);//A pointer to a function a that takes an integer argument and returns an integer

int (*a[10])(int);//An array of 10 pointers to functions that take an integer argument and return an integer

5,Static

1)函数体内,声明为static的变量,在函数被调用过程中其值保持不变

2)函数体外,模块内,声明为static的变量可以被模块内所有函数访问,但不能被模块外其它函数访问。它是一个本地的全局变量。

3)函数体外,模块内,声明为static的函数只可被这个模块内的其它函数调用。这个函数被限制在声明它的模块的本地范围内使用。

6,Const

意味着只读。

const int a;//常整形数

int const a;//常整形数

const int *a;//指向常整数的指针。整型数不可修改,指针可修改

int * const a;//指向整型数的常指针。整型数可以修改,指针不可修改

int const * a const;//指向常整型数的常指针。指针指向的整型数不可修改,指针不可修改

7,Volatile

意味着变量会被意想不到地改变。这样,优化器用到这个变量时必须每次都小心地重新读取这个变量的值。

几个典型应用场景:

1)并行设备的硬件寄存器

2)中断服务子程序会访问到的非自动变量

3)多线程应用中被几个任务共享的变量

问题:

1)一个参数既可以使const还可以是volatile吗?

2)一个指针可以是volatile吗?

3)下面函数有什么错误?

int square (volatile int *ptr){

return *ptr  * *ptr;

}

答案:

1)是的。只读状态寄存器,volatile因为它可能被意想不到地改变。const因为程序不应该试图修改它。

2)是的。

3)正确代码。

int square (volatile int *ptr){

int a;

a=*ptr;

return a*a;

}

8,位操作Bit manipulation

11,代码例子Code examples

void foo(void){

unsigned int a=6;

int b=-20;

(a+b>6)puts(">6"):puts("<=6")

}

答案:>6。存在有符号整型和无符号整型时,所有的操作数都自动转换为无符号整型。

14,Typedef

声明一个已经存在的数据类型的同义词。可以用预处理器做类似的事。那种方法更好呢?

#define dPS struct s *

typedef struct s * tPS;

dPS p1,p2;

tPS p3,p4;

第一个扩展为:

struct s * p1,p2;

p1为指向结构的指针,p2为一个实际的结构。第二个例子正确定义p3和p4两个指针。typedef更好。

15,晦涩的语法

int a=5,b=7,c;

c=a+++b;

根据最处理原则,编译器应当能处理尽可能所有合法的用法。理解为:c=a++ + b;运行后a=6,b=7,c=12。

16,什么是引用,声明和使用引用要注意什么?

引用是某个目标变量的别名alias,对引用操作和直接对变量操作完全相同。声明引用时要对其进行初始化。引用声明完成相当于目标变量有2个名称,不能将引用名作为其他变量名的别名。本身不是一种数据类型,引用本身不占存储单元。

17,引用作为函数参数有哪些特点?

1)传递引用给函数与传递指针的效果是一样的。被调函数中对形参变量的操作就是对其相应的目标对象的操作。

2)引用传递函数的参数,内存中没有产生实参的副本,是直接对实参操作;一般变量传递函数参数,发生函数调用时,需要给形参分配存储单元,形参变量 是实参变量的副本。如果传递的是对象,还调用拷贝构造函数。当参数传递的数据较大时,引用比用一般变量传递参数的效率和所占空间都好。

3)使用指针作为函数参数也能得到使用引用的效果。但被调函数中同样要给形参分配存储单元;主调函数的调用点处,必须用变量的地址作为实参。

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

既要用引用提高程序的效率,又要保护传递给函数的数据不在函数中被改变,应使用常引用。

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

好处:内存中不产生被返回值的副本。返回一个局部变量的引用是不可取的,因随着局部变量生存期的结束,相应的引用也会失效,产生runtime error。

1)不能返回局部变量的引用。局部变量在函数返回后被销毁,引用成为无所指的引用,程序进入未知状态。

2)不返回函数内部new分配的内存的引用。被函数返回的引用只是作为一个临时变量出现,没有被赋予一个实际的变量,这个引用指向的空间无法释放,造成memory leak。

3)可返回类成员的引用,最好是const。有必要将赋值操作封装在一个业务规则当中,如果其它对象可以获得该属性的非常量引用(或指针),对该属性的单纯赋值就会破坏业务规则的完整性。

4)刘操作符重载返回值申明为引用的作用

刘操作符<<和>>常希望连续使用,因此其返回值应该是一个仍然支持这2额操作符的流引用。返回一个刘对象,程序必须重新 拷贝构造一个新的流对象,即连续2个<<操作实际上是针对不同的对象,返回一个指针则不能连续使用<<操作符,因此返回一个流对 象引用是唯一选择。赋值操作符返回值必须是一个左值,以便可以被继续赋值。以上说明引用的重要性和无可替代性。

20,引用与多态的关系?

引用是除指针外另一个产生多态效果的手段。一个基类的引用可以指向它的派生类实例。

21,引用与指针的区别?

指针通过某个指针变量指向一个对象后,对它所指向的变量间接操作。而引用本身就是目标变量的别名,对引用的操作就是对目标变量的操作。

22,什么时候需要引用?

流操作符<<和>>、赋值操作符=的返回值;

拷贝构造函数的参数;

赋值操作符=的参数

23,结构和联合

同一时刻,联合中只存放一个被选中的成员,所有成员共用一块地址空间。而结构的所有成员都存在,不同成员的存放地址不同。

对联合的不同成员赋值,将会对其它成员重写,原来成员的值就不存在了,结构的不同成员赋值互不影响。

24,copy字符串

char * strcpy(char * strDst,const * strSrc){

  if(strDst==NULL||strSrc==NULL)

    return NULL;

  if(strDst==strSrc)

    return strDst;

  char * tmpPtr=strDst;

  while( (*strDst++=*strSrc++)!='\0'){;}

  return tmpPtr;

}

25,new/delete与malloc/free的联系和区别?

都是在堆heap上进行动态内存操作。malloc需要指定内存分配的字节数并不能初始化对象,new会自动调用对象的constructor。delete会调用对象的destructor,而free不会调用对象的destructor。

What will be printed as the result of the operation below:

1)

void interviewTest1(){
 char *p1="name"; 
 char *p2;
 p2=(char*)malloc(20); 
 memset (p2, 0, 20); 
 while(*p2++ = *p1++); 
 printf("%s\n",p2); 
}

2)

main(){

int x=20,y=35;

x=y++ + x++;

y=++y + ++x;

printf("%d%dn",x,y);

}

3)

main(){

int x=5;

printf("%d,%d,%dn",x,x<<2,x>>2);

}

4)

#define swap(a,b) a=a+b;b=a-b;a=a-b; 
int swap2(int a, int b) 
int temp; 
temp=a; 
b=a; 
a=temp; 
return 0; 
}

 void main() 
int x=5, y=10; 
swap (x,y); 
printf(“%d %dn”,x,y); 
swap2(x,y); 
printf(“%d %dn”,x,y); 
5)

Answers:

1)empty string

2)5794

3)5,20,1

4)10,5  10,5

5)Cisco System isco System

6)

深入理解调试代码:

1)

void interviewTest1(){
 char *p1="name"; 
 char *p2;
 p2=(char*)malloc(20); 
 memset (p2, 0, 20); 
 printf("p1=%s\n",p1);
 int i=0;
 while(*p2++ = *p1++){
  printf("i=%d\n",++i);
  printf("p1=%s\n",p1);
  printf("p2=%s\n",--p2);
 }
 printf("p1=%s\n",p1);
 printf("p2=%s\n",p2);
 p1=p1-5;
 p2=p2-5;
 printf("p1=%s\n",p1);
 printf("p2=%s\n",p2); 
}

2)

void interviewTest2(){
 int x=20,y=35; 
 x=y++ + x++; 
 printf("x=%d,y=%d\n",x,y); 
 y= ++y + ++x; 
 printf("x=%d,y=%d\n",x,y); 
}

4)

void interviewTest3(){
 int x=5, y=10; 
 //swap (x,y); 
 //printf("x=%d,y=%d\n",x,y); 
 swap2(x,y); 
 printf("x=%d,y=%d\n",x,y); 
}

答案
试题一
3、
阅读(966) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~