新建
上传
首页
助手
最?/div>
资料?/div>
工具

?/p>

1

)什么是预编译,何时需要预编译?/p>

 

答案?/p>

 

 

1、总是使用不经常改动的大型代码体?/p>

 

 

2?/p>

程序由多个模块组成,

所有模块都使用一组标准的包含文件和相同的编译?/p>

项。在这种情况下,可以将所有包含文件预编译为一个预编译头?/p>

 

 

?/p>

2

?/p>

char * const p 

 

 

 

 

 

char const * p 

 

 

 

 

 

const char *p 

上述三个有什么区

别?

 

 

答案?/p>

 

 

char * const p; //

常量指针?/p>

p

的值不可以修改

 

 

char const * p

?/p>

//

指向常量的指针,指向的常量值不可以?/p>

 

const char *p

?/p>

 

//

?/p>

char const *p 

 

?/p>

3

?/p>

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

是数组变量,它们有各自的内存空间;?/p>

str5,str6,str7,str8

是指针,它们指向相同的常量区域?/p>

 

 

?/p>

4

)以下代码中的两?/p>

sizeof

用法有问题吗?/p>

 

 

[C

?/p>

] 

void 

UpperCase( 

char 

str[] 

) 

// 

?/p>

 

str 

中的小写字母转换成大写字?/p>

 

{ 

 

 

 

for( 

size_t 

i=0; 

i 

<sizeof(str)/sizeof(str[0]); 

++i 

) 

 

 

 

 

 

 

 

if( 

'a' 

<=str[i] 

&& 

str[i] <='z' ) 

 

 

 

 

 

 

 

 

 

 

 

str[i] -= ('a'-'A' ); } char str[] = "aBcDe"; cout < < "str

字符

长度?/p>

: " < < sizeof(str)/sizeof(str[0]) < < endl; UpperCase( str ); cout 

< < str < < 

endl; 

答案:函数内?/p>

sizeof

有问题。根据语法,

sizeof

如用于数组,只能测出?/p>

态数组的大小,无法检测动态分配的或外部数组大小。函数外?/p>

str

是一个静?/p>

定义的数组,因此其大小为

6

,因为还?/p>

'\0'

,函数内?/p>

str

实际只是一个指向字

符串的指针,

没有任何额外的与数组相关的信息,

因此

sizeof

作用于上只将其当

指针看,一个指针为

4

个字节,因此返回

4

?/p>

 

 

?/p>

5

)一?/p>

32

位的机器

,

该机器的指针是多少位答案?/p>

 

 

指针是多少位只要看地址总线的位数就行了?/p>

80386

以后的机子都?/p>

32

?/p>

数据总线。所以指针的位数就是

4

个字节了?/p>

 

 

6

?/p>

main() 

{ 

 

int 

a[5]={1,2,3,4,5}; 

 

 

 

int 

*ptr=(int 

*)(&a+1); 

 

 

 

printf("%d,%d",*(a+1),*(ptr-1)); } 

答案?/p>

2

?/p>

5 *(a+1

)就?/p>

a[1]

?/p>

*(ptr-1)

就是

a[4],

执行结果?/p>

2

?/p>

5 &a+1

不是首地址

+1

?/p>

系统会认为加一?/p>

a

数组的偏移,

是偏?/p>

了一个数组的大小

(本例是

5

?/p>

int

?/p>

 

int *ptr=(int *)(&a+1); 

?/p>

ptr

实际?/p>

&(a[5]),

也就?/p>

a+5 

原因如下?/p>

 

&a

是数组指针,其类型为

 

int 

(*)[5]; 

而指针加

1

要根

据指针类型加上一定的值,不同类型的指?/p>

+1

之后增加的大小不?/p>

 

a

是长度为

5

?/p>

int

数组指针?/p>

所以要?/p>

 

5*sizeof(int) 

所?/p>

ptr

实际?/p>

a[5] 

但是

prt

?/p>

(&a+1)

类型是不一样的

(

这点很重?/p>

) 

所?/p>

prt-1

只会减去

sizeof(int*) a,&a

的地址是一?/p>

的,但意思不一样,

a

是数组首地址,也就是

a[0]

的地址?/p>

&a

是对象(数组)首

Ͼλ
新建
上传
首页
助手
最?/div>
资料?/div>
工具

?/p>

1

)什么是预编译,何时需要预编译?/p>

 

答案?/p>

 

 

1、总是使用不经常改动的大型代码体?/p>

 

 

2?/p>

程序由多个模块组成,

所有模块都使用一组标准的包含文件和相同的编译?/p>

项。在这种情况下,可以将所有包含文件预编译为一个预编译头?/p>

 

 

?/p>

2

?/p>

char * const p 

 

 

 

 

 

char const * p 

 

 

 

 

 

const char *p 

上述三个有什么区

别?

 

 

答案?/p>

 

 

char * const p; //

常量指针?/p>

p

的值不可以修改

 

 

char const * p

?/p>

//

指向常量的指针,指向的常量值不可以?/p>

 

const char *p

?/p>

 

//

?/p>

char const *p 

 

?/p>

3

?/p>

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

是数组变量,它们有各自的内存空间;?/p>

str5,str6,str7,str8

是指针,它们指向相同的常量区域?/p>

 

 

?/p>

4

)以下代码中的两?/p>

sizeof

用法有问题吗?/p>

 

 

[C

?/p>

] 

void 

UpperCase( 

char 

str[] 

) 

// 

?/p>

 

str 

中的小写字母转换成大写字?/p>

 

{ 

 

 

 

for( 

size_t 

i=0; 

i 

<sizeof(str)/sizeof(str[0]); 

++i 

) 

 

 

 

 

 

 

 

if( 

'a' 

<=str[i] 

&& 

str[i] <='z' ) 

 

 

 

 

 

 

 

 

 

 

 

str[i] -= ('a'-'A' ); } char str[] = "aBcDe"; cout < < "str

字符

长度?/p>

: " < < sizeof(str)/sizeof(str[0]) < < endl; UpperCase( str ); cout 

< < str < < 

endl; 

答案:函数内?/p>

sizeof

有问题。根据语法,

sizeof

如用于数组,只能测出?/p>

态数组的大小,无法检测动态分配的或外部数组大小。函数外?/p>

str

是一个静?/p>

定义的数组,因此其大小为

6

,因为还?/p>

'\0'

,函数内?/p>

str

实际只是一个指向字

符串的指针,

没有任何额外的与数组相关的信息,

因此

sizeof

作用于上只将其当

指针看,一个指针为

4

个字节,因此返回

4

?/p>

 

 

?/p>

5

)一?/p>

32

位的机器

,

该机器的指针是多少位答案?/p>

 

 

指针是多少位只要看地址总线的位数就行了?/p>

80386

以后的机子都?/p>

32

?/p>

数据总线。所以指针的位数就是

4

个字节了?/p>

 

 

6

?/p>

main() 

{ 

 

int 

a[5]={1,2,3,4,5}; 

 

 

 

int 

*ptr=(int 

*)(&a+1); 

 

 

 

printf("%d,%d",*(a+1),*(ptr-1)); } 

答案?/p>

2

?/p>

5 *(a+1

)就?/p>

a[1]

?/p>

*(ptr-1)

就是

a[4],

执行结果?/p>

2

?/p>

5 &a+1

不是首地址

+1

?/p>

系统会认为加一?/p>

a

数组的偏移,

是偏?/p>

了一个数组的大小

(本例是

5

?/p>

int

?/p>

 

int *ptr=(int *)(&a+1); 

?/p>

ptr

实际?/p>

&(a[5]),

也就?/p>

a+5 

原因如下?/p>

 

&a

是数组指针,其类型为

 

int 

(*)[5]; 

而指针加

1

要根

据指针类型加上一定的值,不同类型的指?/p>

+1

之后增加的大小不?/p>

 

a

是长度为

5

?/p>

int

数组指针?/p>

所以要?/p>

 

5*sizeof(int) 

所?/p>

ptr

实际?/p>

a[5] 

但是

prt

?/p>

(&a+1)

类型是不一样的

(

这点很重?/p>

) 

所?/p>

prt-1

只会减去

sizeof(int*) a,&a

的地址是一?/p>

的,但意思不一样,

a

是数组首地址,也就是

a[0]

的地址?/p>

&a

是对象(数组)首

">
新建
上传
首页
助手
最?/div>
资料?/div>
工具

?/p>

1

)什么是预编译,何时需要预编译?/p>

 

答案?/p>

 

 

1、总是使用不经常改动的大型代码体?/p>

 

 

2?/p>

程序由多个模块组成,

所有模块都使用一组标准的包含文件和相同的编译?/p>

项。在这种情况下,可以将所有包含文件预编译为一个预编译头?/p>

 

 

?/p>

2

?/p>

char * const p 

 

 

 

 

 

char const * p 

 

 

 

 

 

const char *p 

上述三个有什么区

别?

 

 

答案?/p>

 

 

char * const p; //

常量指针?/p>

p

的值不可以修改

 

 

char const * p

?/p>

//

指向常量的指针,指向的常量值不可以?/p>

 

const char *p

?/p>

 

//

?/p>

char const *p 

 

?/p>

3

?/p>

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

是数组变量,它们有各自的内存空间;?/p>

str5,str6,str7,str8

是指针,它们指向相同的常量区域?/p>

 

 

?/p>

4

)以下代码中的两?/p>

sizeof

用法有问题吗?/p>

 

 

[C

?/p>

] 

void 

UpperCase( 

char 

str[] 

) 

// 

?/p>

 

str 

中的小写字母转换成大写字?/p>

 

{ 

 

 

 

for( 

size_t 

i=0; 

i 

<sizeof(str)/sizeof(str[0]); 

++i 

) 

 

 

 

 

 

 

 

if( 

'a' 

<=str[i] 

&& 

str[i] <='z' ) 

 

 

 

 

 

 

 

 

 

 

 

str[i] -= ('a'-'A' ); } char str[] = "aBcDe"; cout < < "str

字符

长度?/p>

: " < < sizeof(str)/sizeof(str[0]) < < endl; UpperCase( str ); cout 

< < str < < 

endl; 

答案:函数内?/p>

sizeof

有问题。根据语法,

sizeof

如用于数组,只能测出?/p>

态数组的大小,无法检测动态分配的或外部数组大小。函数外?/p>

str

是一个静?/p>

定义的数组,因此其大小为

6

,因为还?/p>

'\0'

,函数内?/p>

str

实际只是一个指向字

符串的指针,

没有任何额外的与数组相关的信息,

因此

sizeof

作用于上只将其当

指针看,一个指针为

4

个字节,因此返回

4

?/p>

 

 

?/p>

5

)一?/p>

32

位的机器

,

该机器的指针是多少位答案?/p>

 

 

指针是多少位只要看地址总线的位数就行了?/p>

80386

以后的机子都?/p>

32

?/p>

数据总线。所以指针的位数就是

4

个字节了?/p>

 

 

6

?/p>

main() 

{ 

 

int 

a[5]={1,2,3,4,5}; 

 

 

 

int 

*ptr=(int 

*)(&a+1); 

 

 

 

printf("%d,%d",*(a+1),*(ptr-1)); } 

答案?/p>

2

?/p>

5 *(a+1

)就?/p>

a[1]

?/p>

*(ptr-1)

就是

a[4],

执行结果?/p>

2

?/p>

5 &a+1

不是首地址

+1

?/p>

系统会认为加一?/p>

a

数组的偏移,

是偏?/p>

了一个数组的大小

(本例是

5

?/p>

int

?/p>

 

int *ptr=(int *)(&a+1); 

?/p>

ptr

实际?/p>

&(a[5]),

也就?/p>

a+5 

原因如下?/p>

 

&a

是数组指针,其类型为

 

int 

(*)[5]; 

而指针加

1

要根

据指针类型加上一定的值,不同类型的指?/p>

+1

之后增加的大小不?/p>

 

a

是长度为

5

?/p>

int

数组指针?/p>

所以要?/p>

 

5*sizeof(int) 

所?/p>

ptr

实际?/p>

a[5] 

但是

prt

?/p>

(&a+1)

类型是不一样的

(

这点很重?/p>

) 

所?/p>

prt-1

只会减去

sizeof(int*) a,&a

的地址是一?/p>

的,但意思不一样,

a

是数组首地址,也就是

a[0]

的地址?/p>

&a

是对象(数组)首

Ͼλ">
Ͼλ
Ŀ

华为经典嵌入式面试题集资?- 百度文库
新建
上传
首页
助手
最?/div>
资料?/div>
工具

?/p>

1

)什么是预编译,何时需要预编译?/p>

 

答案?/p>

 

 

1、总是使用不经常改动的大型代码体?/p>

 

 

2?/p>

程序由多个模块组成,

所有模块都使用一组标准的包含文件和相同的编译?/p>

项。在这种情况下,可以将所有包含文件预编译为一个预编译头?/p>

 

 

?/p>

2

?/p>

char * const p 

 

 

 

 

 

char const * p 

 

 

 

 

 

const char *p 

上述三个有什么区

别?

 

 

答案?/p>

 

 

char * const p; //

常量指针?/p>

p

的值不可以修改

 

 

char const * p

?/p>

//

指向常量的指针,指向的常量值不可以?/p>

 

const char *p

?/p>

 

//

?/p>

char const *p 

 

?/p>

3

?/p>

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

是数组变量,它们有各自的内存空间;?/p>

str5,str6,str7,str8

是指针,它们指向相同的常量区域?/p>

 

 

?/p>

4

)以下代码中的两?/p>

sizeof

用法有问题吗?/p>

 

 

[C

?/p>

] 

void 

UpperCase( 

char 

str[] 

) 

// 

?/p>

 

str 

中的小写字母转换成大写字?/p>

 

{ 

 

 

 

for( 

size_t 

i=0; 

i 

<sizeof(str)/sizeof(str[0]); 

++i 

) 

 

 

 

 

 

 

 

if( 

'a' 

<=str[i] 

&& 

str[i] <='z' ) 

 

 

 

 

 

 

 

 

 

 

 

str[i] -= ('a'-'A' ); } char str[] = "aBcDe"; cout < < "str

字符

长度?/p>

: " < < sizeof(str)/sizeof(str[0]) < < endl; UpperCase( str ); cout 

< < str < < 

endl; 

答案:函数内?/p>

sizeof

有问题。根据语法,

sizeof

如用于数组,只能测出?/p>

态数组的大小,无法检测动态分配的或外部数组大小。函数外?/p>

str

是一个静?/p>

定义的数组,因此其大小为

6

,因为还?/p>

'\0'

,函数内?/p>

str

实际只是一个指向字

符串的指针,

没有任何额外的与数组相关的信息,

因此

sizeof

作用于上只将其当

指针看,一个指针为

4

个字节,因此返回

4

?/p>

 

 

?/p>

5

)一?/p>

32

位的机器

,

该机器的指针是多少位答案?/p>

 

 

指针是多少位只要看地址总线的位数就行了?/p>

80386

以后的机子都?/p>

32

?/p>

数据总线。所以指针的位数就是

4

个字节了?/p>

 

 

6

?/p>

main() 

{ 

 

int 

a[5]={1,2,3,4,5}; 

 

 

 

int 

*ptr=(int 

*)(&a+1); 

 

 

 

printf("%d,%d",*(a+1),*(ptr-1)); } 

答案?/p>

2

?/p>

5 *(a+1

)就?/p>

a[1]

?/p>

*(ptr-1)

就是

a[4],

执行结果?/p>

2

?/p>

5 &a+1

不是首地址

+1

?/p>

系统会认为加一?/p>

a

数组的偏移,

是偏?/p>

了一个数组的大小

(本例是

5

?/p>

int

?/p>

 

int *ptr=(int *)(&a+1); 

?/p>

ptr

实际?/p>

&(a[5]),

也就?/p>

a+5 

原因如下?/p>

 

&a

是数组指针,其类型为

 

int 

(*)[5]; 

而指针加

1

要根

据指针类型加上一定的值,不同类型的指?/p>

+1

之后增加的大小不?/p>

 

a

是长度为

5

?/p>

int

数组指针?/p>

所以要?/p>

 

5*sizeof(int) 

所?/p>

ptr

实际?/p>

a[5] 

但是

prt

?/p>

(&a+1)

类型是不一样的

(

这点很重?/p>

) 

所?/p>

prt-1

只会减去

sizeof(int*) a,&a

的地址是一?/p>

的,但意思不一样,

a

是数组首地址,也就是

a[0]

的地址?/p>

&a

是对象(数组)首



ļ׺.doc޸Ϊ.docĶ

  • 19ơ÷Bҵһ
  • ӢҸſκϰ
  • 2011ѧȵһѧνʦѵعܽ
  • subjunctive mood
  • ͼͼʵ鱨
  • ߵȴҵ ڶʽ
  • Ǩִ
  • ְӢһӢunit1lesson2̰
  • ѧѡ
  • 糧__ϰο

վ

԰ Ͼλ
ϵͷ779662525#qq.com(#滻Ϊ@)