Adobe面试题

资源来自大街的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:

#include <iostream>
#include <string>
using namespace std;

void println(const string& msg)
{
	cout<<msg<<endl;
}

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<<"-------------------"<<endl;
	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的默认构造函数，然后调用赋值操作符的重载函数

--------------------------------------------------测试代码---------------------------------------------------------

class A
{
	int _counter;
public:
	A() {cout<<"in A()"<<endl;}
	A(int i):_counter(i) {_counter= 0 ;cout<<"in A(int i)"<<endl;}
	A(const A &a) {_counter = a._counter; cout<<"A(const A &a)"<<endl;}
	A& operator = (const A &a) 
	{ 
		if(this == &a ) 
			return *this;
		_counter = a._counter;
		cout<<"in A& operator = (const A &a) "<<endl;
		return *this;
	}
};

class B
{
	A _a;
public:
	B(A &a)
	{
		_a = a;
	}
};

void main()
{
	A a(1);
	cout<<"=============================="<<endl;
	B b(a);
}

输出结果：

in A()

in A& operator = (const A &a)

==========================我是问题分割线==========================

空类的系统自动产生的函数（至少写四个）

默认构造函数；

默认拷贝构造函数；

默认的operator = 函数

析构函数

上述这几个是确认的，

还有一个取值函数： const Empty* operator&() const; 这个我还不太确认

==========================我是问题分割线==========================

怎样防止类被继承？对于不能被继承的类，怎样初始化及销毁它的示例呢？

我的第一想法就是将构造函数私有化，然后用静态成员函数在堆上新建实例，

如果将析构函数也私有化，那么需要一个静态成员函数来做‘善后’工作

貌似这也符合提议，更加复杂的方法可见：猛点我

--------------------------------------------------测试代码---------------------------------------------------------

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这个函数

/*
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 != '\0' && --max_num >= 0 )
	{
		*pDst++ = *pSrc++;
	}

	for( int i=0; i<max_num; i++ )
		*pDst++ = 0;

	return dst;
}

==========================我是问题分割线==========================
对于给定的一个数字，将其对应的二进制的最右边的1改为0（"turn off")，例如给你14， 二进制位1110， 函数处理后为1100，对应为12，写出实现这个功能的函数

#include   <iostream>
#include   <bitset> 
using namespace std;

void Turnoff(int &number)
{
	int int_len = sizeof(int);
	int mask = 1;

	for( int i=0; i<int_len*8; 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:"<<myset<<endl;
	Turnoff(number);
	myset = number;
	cout<<"after turning off: "<<myset<<endl;
}