1、 通过封装，对象的全部属性和操作结合在一起，形成一个整体；
通过封装，一个对象的实现细节被尽可能地隐藏起来；（不可见）
通过封装，每个对象都成为相对独立的实体；
2、 数值型常量有整型常量,实型常量,不论是整型常量还是实型常量都有正值和负值之分；
在C语言的预编译处理中,可以用符号名代表一个常量,定义时不必指定常量类型；
常量的定义就是常量是在程序运行过程中值不能够被改变的量；
3、下列程序的输出结果：72.
#include<iostream>
#include<cstdlib >
using namespace std;
int main() {
char a=101;
int sum=200;
a+=27;sum+=a;
cout<<sum<<endl;
}
分析：char类型的范围是-128---+127，当a+=27，之后a的值超出可表示范围会变为-128.
a为char型,-128~127,a=101,a+=27后溢出a=-128:
a=127时不溢出 01111111(127补码)
a+=1时溢出 10000000(-128补码)
sum += a;
sum为int型，a(char提升为int)
10000000------->11111111 11111111 11111111 10000000(-128补码)
所以,sum=200-128:00000000 00000000 00000000 11001000
+11111111 11111111 11111111 10000000
----------------------------------------------------------------------------------
00000000 00000000 00000000 01001000 (64+8=72)
3、 具有相同类型的指针类型变量p与数组a，不能进行的操作是:D
A p=a;// a表示数组a的地址指针，a和p类型相同，所以p=a操作正确；
B *p=a[0];//*p表示p指向的值，a[0]表示数组的第一个值，两者类型相同，可赋值，正确；
C p=&a[0];//&a[0]是数组第一个元素的地址，与a相同，也是指针，可赋值，正确；
D p=&a;// 设数组a[3]，指针为int *p，a本身是一个指针，而&a的类型int(*)[3]，而不是int *，但p不一定是int型的，所以p=&a错误。
数组名是一级指针，数组地址为二级指针。
4、有一个类A，其数据成员如下：
class A {
……
private:
int a;
public:
const int b;
float* &c;
static const char * d;
static double *e;
};
则构造函数中，成员变量一定要通过初始化列表来初始化的是： b，c、 （此处可以参考学习点击打开链接）
分析：构造函数初始化时必须采用初始化列表一共有三种情况：
1）.需要初始化的数据成员是对象(继承时调用基类构造函数)；
2）.需要初始化const修饰的类成员；
3）.需要初始化引用成员数据；
因为static属于类并不属于具体的对象，所以 static成员是不允许在类内初始化的，那么static const 成员是不是在初始化列表中呢？
答案是NO
一是static属于类，它在未实例化的时候就已经存在了，而构造函数的初始化列表，只有在实例化的时候才执行。
二是static成员不属于对象。我们在调用构造函数自然是创建对象，一个跟对象没直接关系的成员要它做什么呢。
分析二：初始化：从无到有，创建了新对象；如：string foo = "HelloWorld!"
赋值：没有创建新对象，而是对已有对象赋值。如：string bar; bar = "Hello World!"
有时我们可以忽略数据成员初始化和赋值之间的差异,但并非总能这样。
如果成员是const或者是引用的话，必须将其初始化。类似的，当成员属于某种类类型且该类没有定义默认构造函数时，也必须将这个成员初始化。(比如：类A中有一成员是B b，但类B中没有定义默认构造函数时，就必须对A中b成员进行初始化)
随着构造函数体一开始执行（即大括号里面部分），初始化就完成了（构造函数体内只是赋值操作）。因此，上面三种情况，比如初始化const或者引用类型的数据成员的唯一机会就是通过构造函数初始值，形如：ConstRef::ConstRef(int n): i(n), j(n) { }
5、存在性就是变量生命周期。可见性就是能访问。内部静态类就是只有在包含该类的上下文里才能使用的类，比如在一个类内部定义的类，但它是全局存在的。因此内部静态类的可见性和存在性不一致。
6、转义字符的定义为：所有的 ASCII码都可以用“\”加数字（一般是8进制数字）来表示。而C中定义了一些字母前加"\"来表示常见的那些不能显示的ASCII字符，如\0,\t,\n等，就称为转义字符，因为后面的字符，都不是它本来的ASCII字符意思了。
7、对下述代码执行后，会出现：数组越界问题。
charszMsisdn[MAX_LEN_MSISDN-1]; //建立一个长度为MAX_LEN_MSISDN-1的数组，下标范围应为0~MAX_LEN_MSISDN-2
szMsisdn[sizeof(szMsidn)='\0']; //sizeof(szMsidn)得到的是数组长度，为MAX_LEN_MSISDN-1，那么szMsisdn[sizeof(szMsidn)]= szMsisdn[MAX_LEN_MSISDN-1]/ //，很明显数组越界了8、testArray是一个包含8个元素的int型数组，请问sizeof(testArray)/sizeof(testArray[0])=8、
分析：sizeof(testArray)是数组大小8*4=32;
sizeof(testArray[0])是testArray[0]的大小4；
所以sizeof(testArray)/sizeof(testArray[0])=8
#include<iostream>
#include<cstdlib>
using namespace std;
int main() {
inttestArray[8]={0};
cout<<sizeof(testArray)/sizeof(testArray[0]);
}9、
#include<iostream>
#include<cstdlib>
using namespace std;
int main() {
char*a[]={"work","at","alibaba"};
char**pa=a;
cout<<pa<<endl;
cout<<*pa<<endl;
cout<<**pa<<endl;
pa++;
cout<<*pa<<endl;
}
打印结果：
0x22fe30
work
w
at
分析：首先对编译器来说没有数组这一概念，数组都被看成指针，所以a[]就是*a，那么就是**a换成了**pa，pa即是a，换个名字而已，根据数组的++，也就是取a[1][]的值，即“at”。
数组里存储的是指针；
而我们创建的变量pa相当于指向指针的指针是一个二级指针；
所以我们联系之前所学的内容，其实呢就是pa指向了数组的首元素，++一次使得其指向下一个元素。
