2016最新嵌入式笔试题及答案

相关推荐

2016最新嵌入式笔试题及答案

　　嵌入式系统是软件和硬件的综合体，还可以涵盖机械等附属装置。那么嵌入式考试笔试的试题你做了吗?下面跟yjbys小编一起来看看吧!

2016最新嵌入式笔试题及答案

　　1. 以下三条输出语句分别输出什么?

　　char str1[] = "abc";

　　char str2[] = "abc";

　　const char str3[] = "abc";

　　const char str4[] = "abc";

　　const char* str5 = "abc";

　　const char* str6 = "abc";

　　cout << boolalpha << ( str1==str2 ) << endl; // 输出什么?

　　cout << boolalpha << ( str3==str4 ) << endl; // 输出什么?

　　cout << boolalpha << ( str5==str6 ) << endl; // 输出什么?

　　答：分别输出false,false,true。str1和str2都是字符数组，每个都有其自己的存储区，它们的值则是各存储区首地址，不等;str3和str4同上，只是按const语义，它们所指向的数据区不能修改。str5和str6并非数组而是字符指针，并不分配存储区，其后的“abc”以常量形式存于静态数据区，而它们自己仅是指向该区首地址的指针，相等。

　　3. 非C++内建型别 A 和 B，在哪几种情况下B能隐式转化为A?

　　答：

　　a. class B : public A { ……} // B公有继承自A，可以是间接继承的

　　b. class B { operator A( ); } // B实现了隐式转化为A的转化

　　c. class A { A( const B& ); } // A实现了non-explicit的参数为B(可以有其他带默认值的参数)构造函数

　　d. A& operator= ( const A& ); // 赋值操作，虽不是正宗的隐式类型转换，但也可以勉强算一个

　　4. 以下代码有什么问题?

　　struct Test

　　{

　　Test( int ) {}

　　Test() {}

　　void fun() {}

　　};

　　void main( void )

　　{

　　Test a(1);

　　a.fun();

　　Test b();

　　b.fun();

　　}

　　答：变量b定义出错。按默认构造函数定义对象，不需要加括号。

　　5. 以下代码有什么问题?

　　cout << (true?1:"1") << endl;

　　答：三元表达式“?:”问号后面的两个操作数必须为同一类型。

　　6. 以下代码能够编译通过吗，为什么?

　　unsigned int const size1 = 2;

　　char str1[ size1 ];

　　unsigned int temp = 0;

　　cin >> temp;

　　unsigned int const size2 = temp;

　　char str2[ size2 ];

　　答：str2定义出错，size2非编译器期间常量，而数组定义要求长度必须为编译期常量。

　　During my test in linux environment. The above code could be compiled successfully. But if we initialize the defined arrary like this “char str2[ size2 ] = {0};”, there would be a compile error informing that “variable-sized object `str2' may not be initialized”.

　　7. 以下反向遍历array数组的方法有什么错误?

　　vector array;

　　array.push_back( 1 );

　　array.push_back( 2 );

　　array.push_back( 3 );

　　for( vector::size_type i=array.size()-1; i>=0; --i ) // 反向遍历array数组

　　{

　　cout << array[i] << endl;

　　}

　　答：首先数组定义有误，应加上类型参数：vector array。其次vector::size_type被定义为unsigned int，即无符号数，这样做为循环变量的i为0时再减1就会变成最大的整数，导致循环失去控制。

　　8. 以下代码中的输出语句输出0吗，为什么?

　　struct CLS

　　{

　　int m_i;

　　CLS( int i ) : m_i(i) {}

　　CLS()

　　{

　　CLS(0);

　　}

　　};

　　CLS obj;

　　cout << obj.m_i << endl;

　　答：不能。在默认构造函数内部再调用带参的构造函数属用户行为而非编译器行为，亦即仅执行函数调用，而不会执行其后的初始化表达式。只有在生成对象时，初始化表达式才会随相应的构造函数一起调用。

　　9. C++中的空类，默认产生哪些类成员函数?

　　答：

　　class Empty

　　{

　　public:

　　Empty(); // 缺省构造函数

　　Empty( const Empty& ); // 拷贝构造函数

　　~Empty(); // 析构函数

　　Empty& operator=( const Empty& ); // 赋值运算符

　　Empty* operator&(); // 取址运算符

　　const Empty* operator&() const; // 取址运算符 const

　　};

　　10. 以下两条输出语句分别输出什么?

　　float a = 1.0f;

　　cout << (int)a << endl;

　　cout << (int&)a << endl;

　　cout << boolalpha << ( (int)a == (int&)a ) << endl; // 输出什么?

　　float b = 0.0f;

　　cout << (int)b << endl;

　　cout << (int&)b << endl;

　　cout << boolalpha << ( (int)b == (int&)b ) << endl; // 输出什么?

　　答：分别输出false和true。注意转换的应用。(int)a实际上是以浮点数a为参数构造了一个整型数，该整数的值是1，(int&)a则是告诉编译器将a当作整数看(并没有做任何实质上的转换)。因为1以整数形式存放和以浮点形式存放其内存数据是不一样的，因此两者不等。对b的两种转换意义同上，但是0的整数形式和浮点形式其内存数据是一样的，因此在这种特殊情形下，两者相等(仅仅在数值意义上)。

　　注意，程序的输出会显示(int&)a=1065353216，这个值是怎么来的呢?前面已经说了，1以浮点数形式存放在内存中，按ieee754规定，其内容为0x0000803F(已考虑字节反序)。这也就是a这个变量所占据的内存单元的值。当(int&)a出现时，它相当于告诉它的上下文：“把这块地址当做整数看待!不要管它原来是什么。”这样，内容0x0000803F按整数解释，其值正好就是1065353216(十进制数)。

　　通过查看汇编代码可以证实“(int)a相当于重新构造了一个值等于a的整型数”之说，而(int&)的作用则仅仅是表达了一个类型信息，意义在于为cout<<及==选择正确的重载版本。

　　①链表反转

　　单向链表的反转是一个经常被问到的一个面试题，也是一个非常基础的问题。比如一个链表是这样的： 1->2->3->4->5 通过反转后成为5->4->3->2->1。

　　最容易想到的方法遍历一遍链表，利用一个辅助指针，存储遍历过程中当前指针指向的下一个元素，然后将当前节点元素的指针反转后，利用已经存储的指针往后面继续遍历。源代码如下：

　　1. struct linka {

　　2. int data;

　　3. linka* next;

　　4. };

　　5. void reverse(linka*& head) {

　　6. if(head ==NULL)

　　7. return;

　　8. linka *pre, *cur, *ne;

　　9. pre=head;

　　10. cur=head->next;

　　11. while(cur)

　　12. {

　　13. ne = cur->next;

　　14. cur->next = pre;

　　15. pre = cur;

　　16. cur = ne;

　　17. }

　　18. head->next = NULL;

　　19. head = pre;

　　20. }

　　还有一种利用递归的方法。这种方法的基本思想是在反转当前节点之前先调用递归函数反转后续节点。源代码如下。不过这个方法有一个缺点，就是在反转后的最后一个结点会形成一个环，所以必须将函数的返回的节点的next域置为NULL。因为要改变head指针，所以我用了引用。算法的源代码如下：

　　1. linka* reverse(linka* p,linka*& head)

　　2. {

　　3. if(p == NULL || p->next == NULL)

　　4. {

　　5. head=p;

　　6. return p;

　　7. }

　　8. else

　　9. {

　　10. linka* tmp = reverse(p->next,head);

　　11. tmp->next = p;

　　12. return p;

　　13. }

　　14. }

　　②已知String类定义如下：

　　class String

　　{

　　public:

　　String(const char *str = NULL); // 通用构造函数

　　String(const String &another); // 拷贝构造函数

　　~ String(); // 析构函数

　　String & operater =(const String &rhs); // 赋值函数

　　private:

　　char *m_data; // 用于保存字符串

　　};

　　尝试写出类的成员函数实现。

　　答案：

　　String::String(const char *str)

　　{

　　if ( str == NULL ) //strlen在参数为NULL时会抛异常才会有这步判断

　　{

　　m_data = new char[1] ;

　　m_data[0] = '/0' ;

　　}

　　else

　　{

　　m_data = new char[strlen(str) + 1];

　　strcpy(m_data,str);

　　}

　　String::String(const String &another)

　　{

　　m_data = new char[strlen(another.m_data) + 1];

　　strcpy(m_data,other.m_data);

　　}

　　String& String::operator =(const String &rhs)

　　{

　　if ( this == &rhs)

　　return *this ;

　　delete []m_data; //删除原来的数据，新开一块内存

　　m_data = new char[strlen(rhs.m_data) + 1];

　　strcpy(m_data,rhs.m_data);

　　return *this ;

　　}

　　String::~String()

　　{

　　delete []m_data ;

　　}

　　③网上流传的c++笔试题汇总

　　1. 求下面函数的返回值(微软)

　　int func(x)

　　{

　　int countx = 0;

　　while(x)

　　{

　　countx ++;

　　x = x&(x-1);

　　}

　　return countx;

　　}

　　假定x = 9999。答案：8

　　思路：将x转化为2进制，看含有的1的个数。

　　2. 什么是“引用”?申明和使用“引用”要注意哪些问题?

　　答：引用就是某个目标变量的“别名”(alias)，对应用的操作与对变量直接操作效果完全相同。申明一个引用的时候，切记要对其进行初始化。引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，不能再把该引用名作为其他变量名的别名。声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。不能建立数组的引用。

　　3. 将“引用”作为函数参数有哪些特点?

　　(1)传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象(在主调函数中)的操作。

　　(2)使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作;而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本;如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。

　　(3)使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用"*指针变量名"的形式进行运算，这很容易产生错误且程序的阅读性较差;另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。

　　4. 在什么时候需要使用“常引用”?

　　如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。常引用声明方式：const 类型标识符 &引用名=目标变量名;

　　例1

　　int a ;

　　const int &ra=a;

　　ra=1; //错误

　　a=1; //正确

　　例2

　　string foo( );

　　void bar(string & s);

　　那么下面的表达式将是非法的：

　　bar(foo( ));

　　bar("hello world");

　　原因在于foo( )和"hello world"串都会产生一个临时对象，而在C++中，这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型，这是非法的。

　　引用型参数应该在能被定义为const的情况下，尽量定义为const 。

　　5. 将“引用”作为函数返回值类型的格式、好处和需要遵守的规则?

　　格式：类型标识符 &函数名(形参列表及类型说明){ //函数体 }

　　好处：在内存中不产生被返回值的副本;(注意：正是因为这点原因，所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束，相应的引用也会失效，产生runtime error!

　　注意事项：

　　(1)不能返回局部变量的引用。这条可以参照Effective C++[1]的Item 31。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。

　　(2)不能返回函数内部new分配的内存的引用。这条可以参照Effective C++[1]的Item 31。虽然不存在局部变量的被动销毁问题，可对于这种情况(返回函数内部new分配内存的引用)，又面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间(由new分配)就无法释放，造成memory leak。

　　(3)可以返回类成员的引用，但最好是const。这条原则可以参照Effective C++[1]的Item 30。主要原因是当对象的属性是与某种业务规则(business rule)相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用(或指针)，那么对该属性的单纯赋值就会破坏业务规则的完整性。

　　(4)流操作符重载返回值申明为“引用”的作用：

　　流操作符<<和>>，这两个操作符常常希望被连续使用，例如：cout << "hello" << endl;　因此这两个操作符的返回值应该是一个仍然支持这两个操作符的流引用。可选的其它方案包括：返回一个流对象和返回一个流对象指针。但是对于返回一个流对象，程序必须重新(拷贝)构造一个新的流对象，也就是说，连续的两个<<操作符实际上是针对不同对象的!这无法让人接受。对于返回一个流指针则不能连续使用<<操作符。因此，返回一个流对象引用是惟一选择。这个唯一选择很关键，它说明了引用的重要性以及无可替代性，也许这就是C++语言中引入引用这个概念的原因吧。赋值操作符=。这个操作符象流操作符一样，是可以连续使用的，例如：x = j = 10;或者(x=10)=100;赋值操作符的返回值必须是一个左值，以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。

　　例3

　　#i nclude

　　int &put(int n);

　　int vals[10];

　　int error=-1;

　　void main()

　　{

　　put(0)=10; //以put(0)函数值作为左值，等价于vals[0]=10;

　　put(9)=20; //以put(9)函数值作为左值，等价于vals[9]=20;

　　cout<

　　}

　　int &put(int n)

　　{

　　if (n>=0 && n<=9 ) return vals[n];

　　else { cout<<"subscript error"; return error; }

　　}

　　(5)在另外的一些操作符中，却千万不能返回引用：+-*/ 四则运算符。它们不能返回引用，Effective C++[1]的Item23详细的讨论了这个问题。主要原因是这四个操作符没有side effect，因此，它们必须构造一个对象作为返回值，可选的方案包括：返回一个对象、返回一个局部变量的引用，返回一个new分配的对象的引用、返回一个静态对象引用。根据前面提到的引用作为返回值的三个规则，第2、3两个方案都被否决了。静态对象的引用又因为((a+b) == (c+d))会永远为true而导致错误。所以可选的只剩下返回一个对象了。

　　6. “引用”与多态的关系?

　　引用是除指针外另一个可以产生多态效果的手段。这意味着，一个基类的引用可以指向它的派生类实例。

　　例4

　　Class A; Class B : Class A{...}; B b; A& ref = b;

　　7. “引用”与指针的区别是什么?

　　指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差;而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。此外，就是上面提到的对函数传ref和pointer的区别。

　　8. 什么时候需要“引用”?

　　流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。

　　以上 2-8 参考：http://blog.csdn.net/wfwd/archive/2006/05/30/763551.aspx

　　9. 结构与联合有和区别?

　　1. 结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选中的成员(所有成员共用一块地址空间), 而结构的所有成员都存在(不同成员的存放地址不同)。

　　2. 对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的。