C/C++基础知识点整理

 1.

#include<iostream>
using namespace std;
int main()
{
	int aa[8] = {0};
	cout << &aa[0] + 1 << endl;
	cout << &aa[1] << endl;
	//cout << &aa[0]++ << endl;
	cout << aa + 1 << endl;

	return 0;
}

PS：上图所示的三种表示方法都是代表的是数组元aa[1]的地址，注释掉的那一行表达错误，++的优先级是要高于&的

2.某二叉树的后序遍历和中序遍历是一样的都为ABCDEF，那么它按层输出的结果为：FEDCBA

3.在16位IBM-pc上求下面结构体test的sizeof(test)

struct test {
	int m1;//2
	char m2;//1
	float m3;//4
	union uu//5
	{
		char u1[5];
		int u2[2];
	}ua;
}myaa;

ps:所以其大小为12

4.多态类的虚函数表建立在，编译阶段

5.关于纯虚函数正确的是，子类中必须覆盖基类的纯虚函数

---

1.

#include <iostream>
#include <cmath>

int main(){
    int a = 666,b = 888;
    printf("%d\n",a,b);
}

上面的程序运行结果为666，printf()打印的时候从左往右打印。

2.

class C
{
public:
    char a;
    static char b;
    void *p;
    static int *c;
    virtual void func1();
    virtual void func2();
};

那么sizeof(C)的数值是（24），看了大神的解答2333。b和*c都是静态变量，存在全局区中，因此不在计算范围之内，a 是char类型，占用一个字节，p是指针，在64 位系统中占用8个字节，而两个虚函数只需要一个虚函数表指针，也是八个字节，加上类中的对齐方式（char a 对齐时后面补上7个字节），所以答案为24。

3.

已定义 ch 为字符型变量，以下赋值语句中错误的是（A）。

A.ch='\';

B.ch=62+3;//整数给字符赋值

C.ch=NULL;//相当于把0给字符赋值

D.ch='\xaa';//十六进制的表示方式

4.

class Test
{
    public:
        ____ int a;
        ____ int b;
    public:
        Test::Test(int _a , int _b) : a( _a )
        {
             b = _b;
        }
};
int Test::b;
int main(void)
{
    Test t1(0 , 0) , t2(1 , 1);
    t1.b = 10;
    t2.b = 20;
    printf("%u %u %u %u",t1.a , t1.b , t2.a , t2.b);
    return 0;
}

Running result : 0 20 1 20

a可以是const变量也可以是普通变量；b是static变量。

---

1.下面代码段的运行结果（环境linux平台, g++编译器）:

int main() {
    int x = 10;
    int y = 10;
    x = y = ++y;
    printf("%d %d", x, y);
    return 0;
}

PS：输出的结果是11 11，++y和y是一个空间，赋值运算符是从右网左执行的。

2.下面程序段的运行结果、

int main（int argc, char *argv[]）
{
    char *s = "abcdefg";
    s += 2;
    fprintf(stderr, "%d\n", s);
    return 0;
}

PS：字符“c”的地址。

3.下面说法错误的是：父类的指针访问虚函数访问的是父类的方法（×）

4.只能在循环体内和swich语句体内使用break语句（√）

5.多态类中的虚函数表建立在（编译阶段）

6.

C++指向函数的指针定义方式为：

返回类型  (*指针名）  (函数参数列表)  ，例如 void （*p）（int）是指向一个返回值为void 参数为int类型的函数

对于指向成员函数的指针略有不同：

1.指向非静态成员函数：

定义方式：返回类型 （类名::*指针名）（函数参数列表）例如void （A::*p）（int）是一个指向A类中成员函数的函数指针。

赋值方式：p=&A::函数名，而一般的函数指针的赋值是p=函数名即可，注意区别。（成员函数必须是public类型的）

调用方式：成员函数指针的调用必须通过类对象进行调用，a.*p(int)即可调用成员函数（该成员函数是public类型的）

2.静态成员函数

对于静态成员函数的定义和使用方法都与普通函数指针的相同，只是在赋值的时候和非静态成员们函数指针的赋值方法相同。

因为静态成员函数的指针类型是与普通函数指针类型相同的。

7.静态成员函数不能做默认实参（×）

8.

A printf默认右对齐

B printf和scanf是库函数，不是语句

C 正确，函数包括函数头，大括号和函数体三部分，函数体是可执行部分，而赋值语句只能放到函数体里

D printf输出的数据不仅受输出域宽和小数域宽限制，也受数据在内存中存储精度影响

---

1.以下程序的输出的结果是

#include "stdio.h"
main()
{int a=1;int b=2;
for(;a<8;a++) {b+=a;a+=2;}
printf("%d，%d\n",a,b);}

解析：

2.以下程序输出的结果

#include<stdio.h>
main()
{ 
    int s=0,n;
    for(n=0; n<4; n++)
    {
        switch(n)
        {
           default:s+=4;
           case 1:s+=1;
           case 2:s+=2;
           case 3:s+=3;
        }
    }
    printf ("%d\n",s);
}

答案：24 解析：switch语句要是没有break，就会一直执行到整个语句结束。

3.以下程序输出的是

void main (void) {
    char a[] = “SF-TECH” ;
    a++;
    printf (“%s”, a);
}

a不是一个指针变量，什么都不是。

4.有如下函数，则funb(10)为（）

#include <stdio.h>
int func(unsigned int v)
{
    v ^= v >>16;
    v ^= v >> 8;
    v ^= v >> 4;
    v &= 0xf;
    return (0x6996 >> v) & 1;
}
int funb(int n)
{
    unsigned int t = 1 << n;
    int val = 0;
    for (int i = 0; i < t; ++i) {
        val += func(i);
    }
    return val;
}
int main ()
{
    printf("%d", funb(10));// 512
}

---

1.在C语言中，一维数组的定义方式为：元素类型 数组名[E];E为（整型变量或整型表达式）

2.

class A
{
    int _a;
public:
    A(int a): _a(a)
    {
    }
    friend int f1(A &);
    friend int f2(const A &);
    friend int f3(A);
    friend int f4(const A);
};

f1(0)调用错误，0只能给常对象赋值。