Adobe 的客户包括世界各地的企业、知识工作者、创意人士和设计者、OEM 合作伙伴，以及开发人员。下面一起来看看Adobe的认证考试题库，希望对大家有所帮助!
what is the rule of class D_*, UserCalss, and client class of D_* and UserClass to access the member of class B
class B{/*... ...*/};
class D_pri:private B{/*... ...*/};
class D_publ:public B{/*... ...*/};
class UserClass{ B b; /*... ...*/}
D_pri: 私有继承自B，那么B中的public, private, protected在D_pri中修改为private，
“private继承会将基类中的public和protected可见性的成员修改成为private可见性，这样一来虽然派生类中同样还是可以调用基类的protected和public成员，但是在派生类的派生类就不可以再调用被private继承的基类的成员了。” from here
D_publ: 公有继承自B，B中的三种类型在这个派生类中保持不变，派生类可以调用基类的protected和public成员，但是无法调用private成员
UserClass: 有一个B的对象b，b可以访问b中的public成员函数及成员变量，但是无法访问private和protected成员函数与变量
==========================我是问题分割线==========================
write the output:
[cpp] view plain copy print?
#include
#include
using namespace std;
void println(const string& msg)
{
cout<
}
class Base
{
public:
Base() { println("Base::Base()"); virt(); }
void f() { println("Base::f()"); virt(); }
virtual void virt() { println("Base::virt()"); }
};
class Derived :public Base
{
public:
Derived() { println("Derived::Derived()"); virt(); }
virtual void virt() { println("Derived::virt()"); }
};
void main()
{
Derived d;
cout<<"-------------------"<
Base *pB = &d;
pB->f();
}
output:
Base::Base()
Base::virt()
Derived::Derived()
Derived::virt()
-------------------
Base::f()
Derived::virt()
很少会在构造函数和析构函数中调用虚函数，因为在它们中调用的虚函数将失去“多态”功能
==========================我是问题分割线==========================
static_cast 和 dynamic_cast有什么区别：
static_cast 没有运行时类型检查来保证转换的'安全性;
dynamic_cast 用于类层次间(有继承关系的)的向上或者向下类型转换，也可以在兄弟类别中进行转换，它的安全性由RTTI来保证;
特别是当处理向下类型转换时用static_cast貌似成功转换的结果也许会造成遭难， 若无法进行向下类型转换dynamic_cast会返回NULL.
参考：点击打开链接
《Thinking in C++》
==========================我是问题分割线==========================
const char *p
char const *p;
前两个的意思是一样的，都是表示指向只读(const)char型变量的指针，所以不能进行 *p = 2; 这类修改被指对象值的操作
char * const p;
指针p是只读的，指针的值不能修改，比如p++不可以。
const char const *p;
这个指针即指向只读类型char的变量，本身又是只读的
==========================我是问题分割线==========================
下面类的两种构造函数有什么区别
Sample::Sample(string name):_name(name){}
Sample::Sample(string name):{_name=name;}
----------------------------------------------我是回答分割线----------------------------------------------------
第一个调用了string的拷贝构造，
第二个比较麻烦，先调用string的默认构造函数，然后调用赋值操作符的重载函数
--------------------------------------------------测试代码---------------------------------------------------------
[cpp] view plain copy print?
class A
{
int _counter;
public:
A() {cout<<"in A()"<
A(int i):_counter(i) {_counter= 0 ;cout<<"in A(int i)"<
A(const A &a) {_counter = a._counter; cout<<"A(const A &a)"<
A& operator = (const A &a)
{
if(this == &a )
return *this;
_counter = a._counter;
cout<<"in A& operator = (const A &a) "<
return *this;
}
};
class B
{
A _a;
public:
B(A &a)
{
_a = a;
}
};
void main()
{
A a(1);
cout<<"=============================="<
B b(a);
}
输出结果：
in A()
in A& operator = (const A &a)
==========================我是问题分割线==========================
空类的系统自动产生的函数(至少写四个)
默认构造函数;
默认拷贝构造函数;
默认的operator = 函数
析构函数
上述这几个是确认的，
还有一个取值函数： const Empty* operator&() const; 这个我还不太确认
==========================我是问题分割线==========================
怎样防止类被继承?对于不能被继承的类，怎样初始化及销毁它的示例呢?
我的第一想法就是将构造函数私有化，然后用静态成员函数在堆上新建实例，
如果将析构函数也私有化，那么需要一个静态成员函数来做‘善后’工作
貌似这也符合提议，更加复杂的方法可见：猛点我
--------------------------------------------------测试代码---------------------------------------------------------
[cpp] view plain copy print?
class uninheritable
{
int _value;
uninheritable(int v): _value(v){}
~uninheritable() {};
public:
static uninheritable *create(int v);
static void delete_uninherit(uninheritable* uninherit);
};
uninheritable* uninheritable::create(int v)
{
return new uninheritable(v);
}
void uninheritable::delete_uninhert(uninheritable* uninherit)
{
if( uninherit )
{
delete uninherit;
uninherit = NULL;
}
}
可以这么写，编译通过
class derived : public uninheritable
{
// add what you want the class to do
};
但是，如果你想初始化derived类的一个对象，那么编译器报错，因为基类的构造函数是私有的，派生类的构造函数无法调用基类的私有成员函数
==========================我是问题分割线==========================
产生继承类实例时构造函数的调用次序(基类包含虚函数，继承类重写了)
基类构造函数先被调用，然后再调用派生类的构造函数，而且基类构造函数在派生类构造函数的初始化列表中被调用，
如果有继承自多个基类，那么按照public A，B，C的依次顺序，而不是在初始化列表中的顺序。
貌似这题很简单啊，但是为什么强调“基类包含虚函数，继承类重写了”
想来想去只有虚函数表指针的初始化问题，所以应该是这样：
设置基类vptr, 然后执行基类构造函数的初始化列表，执行基类构造函数体，
再进行派生类初始化列表中其他初始化(比如先进行成员对象，再内建类型初始化，假设有)，然后派生类的vptr初始化，然后进入派生类构造函数体。
还要再查权威的C++书。
==========================我是问题分割线==========================
手工实现 strcpy 函数，不能使用任何库函数，要求处理 NULL、溢出等异常：
可能以下函数没有完全符合题意，模仿了strncpy这个函数
[cpp] view plain copy print?
/*
Description: Copies the first num characters of source to destination
dst:
Pointer to the destination array where the content is to be copied.
src
string to be copied.
num
Maximum number of characters to be copied from source.
*/
char* mystrncpy(char *dst, const char *src, size_t num)
{
if( NULL == dst )
return NULL;
if( NULL == src )
return dst;
const char *pSrc = src;
char *pDst = dst;
int max_num = num;
while( *pSrc != ' ' && --max_num >= 0 )
{
*pDst++ = *pSrc++;
}
for( int i=0; i
*pDst++ = 0;
return dst;
}
==========================我是问题分割线==========================
对于给定的一个数字，将其对应的二进制的最右边的1改为0("turn off")，例如给你14， 二进制位1110， 函数处理后为1100，对应为12，写出实现这个功能的函数
[cpp] view plain copy print?
#include
#include
using namespace std;
void Turnoff(int &number)
{
int int_len = sizeof(int);
int mask = 1;
for( int i=0; i
{
if( (mask & number) > 0 )
{
number = number - mask;
break;
}
mask = mask << 1;
}
}
void main()
{
int number=1240;
bitset <32> myset(number);
cout<<"before turning off:"<
