小胖子吃辣肉面的专栏

<br />#include <iostream>class TestPrint{public: void Print() { std::cout << "TestPrint" << std::endl; } void Print() const { std::cout << "const TestPrint" << std::endl; } void Print() vol

    A. It calls the class default constructor for each element of the array.    B. It calls the class copy constructor for each element of the array.    C. It calls operator new[](size_t).    D. It calls operator new[](size_t, int).    E. It stores the num

<br />class Base{ public: Base(){cout << "In Base Ctor/n";} class Nest { public: Nest(){cout << "In Nest Ctor/n"; } }; };class Derive : public Base{ public: Derive(){cout << "In De

<br />A. ~Y()   ~X()   ~A()<br />B. ~X()   ~A()   ~Y()<br />C. ~Y()   ~A()   ~X()<br />D. ~A()   ~Y()   ~X()<br />E. ~X()   ~Y()   ~A()<br /><br /><br />C<br /><br /><br />构造函数调用次序： 基类构造函数（按申明顺序）  派生类成员变量构造函数   派生类自己构造函数<br /><br />析构函数调用次序： 与基类完全相反

<br />    A. std::basic_istream<wchar_t, char_traits<wchar_t> ><br />    B. std::basic_istream<char, char_traits<char> ><br />    C. std::istream<char, char_traits<char> ><br />    D. std::istream<wchar_t, char_traits<wchar_t> ><br />    E. std::wistream<c

<br />    A. #define MESSAGE "Whoever said that you could run this program" &<br />"must not have known what you'd do."<br />    B. #define GREETING = "Hello!"<br />    C. #define MESSAGE = "This is a long message, but I know you have"<br />#define MESSAGE

<br />    A. setbuffer<br />    B. setfilebuf<br />    C. rdbuf<br />    D. filebuf<br />    E. streambuf

<br />    A. When there is a looping construct that uses a continue more than once<br />    B. When there is a need for the code written today to call code written tomorrow<br />    C. When there is a need to check for the type of an object to determine wh

<br />    A. It only flushes the standard output stream.<br />    B. It puts a newline character into the standard output stream and flushes the standard output stream.<br />    C. It puts an end-of-output character into the standard output stream.<br />  

<br />    A. The base class destructor calls the virtual function override of the derived class through the vtable.<br />    B. The base class destructor cannot call the virtual function override of the derived class because the derived class portion of th

<br />    A. Default arguments cannot be of pointer type.<br />    B. Default arguments cannot be of a user-defined type.<br />    C. Default arguments can never precede non-default arguments.<br />    D. Default arguments exist in the global heap and not

<br />#include <iostream>using namespace std;class Object{public: Object() {} void Print() const { cout << "const" << endl; } void Print() { cout << "mutable" << endl; }};void pri

    A. It can invoke the terminate() handler.    B. Since the object is being destroyed, it is illogical to throw an exception then.    C. The C++ language does not permit it; a throw statement in a destructor will be caught as an error by the compiler.   

<br />int *(*p)[5];<br /> <br />Which of the following statements can be used to allocate memory for the first dimension in order to make p an array of 3 arrays of 5 pointers to type int?<br /> <br />    A. p = new int [3][5]*;<br />    B. p = new int (*)[

template void fn(T a){...}Which of the following methods can the developer use to carry out this specialization?    A. void fn(char* a){...}    B. template void fn(char* a){...}    C. void fn(T a){...}    D. template void fn(char* a){...}    E. template

<br />    A. A reference to a const std::type_info object<br />    B. A const std::type_info object<br />    C. A const reference to a const std::type_info object<br />    D. A reference to a std::type_info object<br />    E. A const reference to a std::ty

<br /> <br />    A. Once an exception is thrown, the compiler unwinds the heap, freeing any memory dynamically allocated within the block from which the exception was thrown.<br />    B. In a hierarchy of exception classes, the order of handling exceptions

<br />class SomeClass{ public: int data; protected: class Nest { public: int nested; }; public: static Nest* createNest(){return new Nest;}};void use_someclass()

<br />class String {<br />public:<br />   //...<br />   //declaration goes here<br />};<br /> <br />    A. char* operator();<br />    B. char* operator char*();<br />    C. String operator char*();<br />    D. operator char*();<br />    E. char* operator S

<br />    A. new SomeClass(pmem);<br />    B. new(pmem) SomeClass;<br />    C. new pmem SomeClass;<br />    D. new SomeClass pmem;<br />    E. new (pmem, SomeClass);<br /><br /><br />B

<br />    A. Has-a<br />    B. Is-implemented-in-terms-of<br />    C. Was-a<br />    D. Can-only-have-one-of<br />    E. Shares-a-relationship-with<br /><br /><br />B

<br />#include <iostream>class Outer{ int m_o; public: class Inner { int m_i; public: Inner(){} Inner(Outer m_outer, int x) { m_outer.m_o = x; } }; Outer(int y)

<br />    A. operator +()<br />    B. operator ++()<br />    C. operator ==()<br />    D. operator ()()<br />    E. operator []()<br /><br /><br /><br />D  function object

A. The getline() function by default, accepts whitespace, and returns on seeing the /n character, whereas the extraction operator returns when it encounters any whitespace character.    B. Delimiters indicating end of input can be specified to the getline(

<br />    A. When no conversion function exists for converting the class object to another class object<br />    B. When an existing object is assigned an object of its own class<br />    C. When a function receives as an argument, an object of the class,

#include #include //Someone else's code, e.g. libraryclass IGlyph{public: virtual ~IGlyph(){} virtual std::string Text()=0; virtual IIcon* Icon()=0; //...};class IWidgetSelector{public: virtual ~IWidgetSe

<br />A. It throws a bad_alloc exception.<br />B. It returns null.<br />C. It returns silently with no effect on the expression.<br />D. It throws an insufficient_memory exception.<br />E. It logs an error message to the mem_err.log file.<br /><br /><br />

A. Write the terminate() function with two int arguments. B. Write the terminate() function with a runtime_error argument. C. Pass the address of the overriding function to the set_terminate() function. D. Write the terminate() function with one

    A. std::allocator::allocate(size_t)    B. std::allocator::malloc(int)    C. std::allocator::make(size_t)    D. std::allocator::new(size_t)    E. std::allocator::acquire(size_t)

A. RTTI does not have standardized run-time behavior. B. RTTI uses too much memory. C. RTTI is too slow. D. RTTI's performance is unpredictable/non-deterministic. E. RTTI frequently fails to function correctly at run-time.B C

<br />    A. void tellg(pos_type&)<br />    B. pos_type tellg()<br />    C. pos_type tellp()<br />    D. void tellp(pos_type&)<br />    E. void seekg(pos_type&)

<br />    A. friend<br />    B. static<br />    C. extern<br />    D. inline<br />    E. member<br /><br /> <br /><br />D

#define language 437            //Line 1#if language #undef language                 //Line 2#else                           //Line 3#define language 850            //Line 4#ifdef language                 //Line 5   printf("%d", language);      //Line 6#en

<br />A. A preprocessor macro expansion cannot work when user-defined types are passed to it as arguments.<br />B. Since the preprocessor does the macro expansion and not the compiler, the build process takes a longer period of time.<br />C. While expandin

<br />A. list<br />B. map<br />C. stack<br />D. queue<br />E. deque<br /><br /><br />顺序性容器vector从后面快速的插入与删除，直接访问任何元素deque从前面或后面快速的插入与删除，直接访问任何元素list双链表，从任何地方快速插入与删除关联容器set快速查找，不允许重复值multiset快速查找，允许重复值map一对多映射，基于关键字快速查找，不允许重复值multimap一对多映射，基于关键字快速查找，允许重复值容器

<br />#include <iostream>using namespace std;class ExBase{private: static int stat;public: static int GetStat(){ return stat; }};int ExBase::stat = 25;class ExDer1 : public ExBase{public: friend int Der1Fn(){ return Ex

<br />template<typename T><br />class MyArray<br />{<br />    //declaration goes here<br />};<br /> <br />    A. T& operator[](size_t i);<br />    B. const T& operator[](size_t i);<br />    C. const T& operator[](size_t i) const;<br />    D. T& operator[](

    A. int main()    B. void main(char* argv[], int argc)    C. int main(int argc, char* argv[])    D. void main()    E. int main(int argc, char* argv[], char* arge[])B

<br />#include <fstream>namespace my_stuff{ class my_class { public: int i; }; //Declaration goes here}//ns my_stuff<br />    A. std::ofstream& operator<<(std::ofstream& ofs, const my_class&);<br />    B. con

int var = 1;void main(){    int i = i;}    A. The i within main will have an undefined value.    B. The compiler will allow this statement, but the linker will not be able to resolve the declaration of i.    C. The i within main will have a value of 1.