### C++笔试题知识点解析
#### 1. 指针与数组的偏移运算
```cpp
#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));
return;
}
```
**知识点解析**：
- **数组名作为指针**：在C/C++中，数组名`a`实际上是一个指向数组首元素的指针。
- **指针的偏移运算**：`&a+1`表示获取整个数组地址后加上一个数组的大小，因此`(int *)(&a+1)`指向了数组`a`之后的内存位置。
- **解引用操作**：`*(a+1)`访问的是数组第二个元素（索引为1），`*(ptr-1)`则访问的是`ptr`所指向的位置之前的元素，即数组的第一个元素。
**输出结果**：`2,1`
#### 2. 自增运算符的使用
```cpp
#include <iostream.h>
void main(void) {
int a = 5, b = 7;
std::cout << (a+++b) <<std::endl;
}
```
**知识点解析**：
- **自增运算符**：`a++`表示先使用`a`的值，然后将`a`的值加1。此处`a+++b`中的`a++`可以理解为`(a++) + b`，即先使用`a`的值（5）加上`b`的值（7），再将`a`加1。
- **输出格式**：使用`std::cout`进行输出，其中`<<`是插入运算符。
**输出结果**：`12`
#### 3. 字符串处理与内存分配
```cpp
#include <iostream.h>
#include <string.h>
void main(void) {
char str[13]="Hello world!";
char *pStr="Hello world!";
void *mp = malloc(10);
std::cout<<sizeof(str)<<std::endl;
std::cout<<sizeof(pStr)<<endl;
std::cout<<strlen(str)<<std::endl;
std::cout<<strlen(pStr)<<std::endl;
std::cout<<sizeof(mp)<<std::endl;
}
```
**知识点解析**：
- **数组大小与指针大小**：`sizeof(str)`返回数组`str`的大小（13字节），`sizeof(pStr)`返回指针`pStr`的大小（64位系统下为8字节）。
- **字符串长度**：`strlen(str)`返回字符串的实际长度（不包括空字符），对于`str`和`pStr`均为12。
- **内存分配**：`malloc`用于动态分配内存，`sizeof(mp)`返回指针`mp`的大小，而不是通过`malloc`分配的内存大小。
**输出结果**：`13 8 12 12 8`
#### 4. 内联函数与条件运算符
```cpp
#include<iostream>
inline void max_out( int val1, int val2 ){
std::cout << ( val1 > val2 ) ? val1 : val2;
}
int main(){
int ix = 10, jx = 20;
max_out( ix, jx );
std::cout << std::endl;
return 0;
}
```
**知识点解析**：
- **内联函数**：`inline`关键字提示编译器将该函数调用处替换为函数体，以减少函数调用的开销。
- **条件运算符**：`?`是条件运算符，语法为`(条件表达式)? 表达式1 : 表达式2`。如果条件表达式为真，则计算并返回表达式1的值；否则计算并返回表达式2的值。
**输出结果**：`20`
#### 5. 虚函数与多态
```cpp
#include<iostream>
class Human {
public:
Human() {
std::cout << "Human start......" << std::endl;
}
virtual void Disp() {
std::cout << "Human disp......" << std::endl;
}
};
class Man: public Human {
public:
Man() {
std::cout << "Man start......" << std::endl;
}
void Disp() {
std::cout << "Man disp......" << std::endl;
}
};
int main(){
Human *pHuman = new Man();
pHuman->Disp();
return 0;
}
```
**知识点解析**：
- **虚函数与多态**：`virtual`关键字使得基类指针可以指向派生类对象，并且能够正确地调用派生类的方法。本例中`pHuman->Disp()`实际调用的是`Man`类的`Disp`方法。
- **构造函数调用顺序**：由于`Man`继承自`Human`，所以先调用基类`Human`的构造函数，再调用派生类`Man`的构造函数。
**输出结果**：`Human start......Man start......Man disp......`
#### 6. 类成员变量初始化
```cpp
#include<iostream>
#include<cstring>
class Dummy{
public:
Dummy(const char* str):m_str(str),m_len(m_str.size()){}
size_t m_len;
string m_str;
};
int main(){
Dummy d("hello");
std::cout << d.m_str << "," << d.m_len << std::endl;
return 0;
}
```
**知识点解析**：
- **成员初始化列表**：构造函数中的`m_str(str),m_len(m_str.size())`表示使用给定的参数初始化成员变量`m_str`和`m_len`。
- **成员变量类型**：`size_t`是无符号整型，通常用于表示大小或数量；`string`是标准库中的字符串类。
**输出结果**：`hello,5`
#### 7. 计算字符中1的个数
```cpp
unsigned int myFunc1(char c) {
int i;
unsigned int num=0, val;
for(i=0; i<8; i++) {
val = c >> i;
val &= 0x01;
if(val) {num++;}
}
return num;
}
```
**知识点解析**：
- **位运算**：通过右移操作将字符的每一位依次移到最低位，然后与`0x01`（二进制`00000001`）进行与运算，从而判断该位是否为1。
- **计数逻辑**：若`val`非零（即为1），则`num`加1，最终返回`num`的值，即字符中1的个数。
#### 8. 字符串转整数
```cpp
int myFunc2(const char * str) {
int num = 0;
int isNegative = 0;
int n =0;
char *p = str;
if(p == NULL) {
return -1;
}
while(*p++ != '\0') {
n++;
}
p = str;
if(p[0] == '-') {
isNegative = 1;
}
char temp = '0';
for(int i = 0 ; i < n; i++) {
char temp = *p++;
if(temp > '9' ||temp < '0') {
continue;
}
if(num !=0 || temp != '0') {
temp -= 0x30;
num += temp *int( pow(10 , n - 1 -i) );
}
}
if(isNegative) {
return (0 - num);
} else {
```
**知识点解析**：
- **字符串遍历**：首先通过`while(*p++ != '\0')`计算字符串长度`n`，然后回到字符串的起始位置。
- **符号判断**：检查第一个字符是否为负号`-`，如果是，则标记`isNegative`为1。
- **数字转换**：逐个字符处理，忽略非数字字符，将数字字符转换为对应的整数值，根据其位置计算对应的值。
- **正负号处理**：最后根据`isNegative`的值决定返回值的正负。
**功能总结**：
这段代码实现了将一个字符串转换成整数的功能，支持处理带负号的情况。
