CPP : C++ Certified Professional Programmer : Part 09

CPP : C++ Certified Professional Programmer : Part 09

1. Which stack initialization (line numbers) are correct? Choose all that apply.

   #include <iostream>
   #include <deque>
   #include <list>
   #include <stack>
   #include <vector>
   using namespace std;

   int main()
   {
   deque<int> mydeck;
   list<int> mylist;
   vector<int> myvector;
   stack<int> first;// Line I
   stack<int> second(mydeck);// Line II
   stack<int> third(second);// Line III
   stack<int, list<int> > fourth(mylist);// Line IV
   stack<int, vector<int> > fifth(myvector);// Line V
   return 0;
   }

   • line I
   • line II
   • line III
   • line IV
   • line V

2. What happens when you attempt to compile and run the following code?

   #include <vector>
   #include <iostream>
   #include <algorithm>
   #include <functional>
   using namespace std;
   template<class T>struct Out {
   ostream & out;
   Out(ostream & o): out(o){}
   void operator() (const T & val ) { out<<val<<” “; } };

   int main() {
   int t[]={3,2,4,1,5,6,10,8,7,9};
   vector<int> v1(t, t+10);
   for_each(v1.begin(), v1.end(), bind2nd(plus<int>(), 1));
   for_each(v1.rbegin(), v1.rend(), Out<int>(cout));cout<<endl;
   return 0;
   }

   Program outputs:

   • 3 2 4 1 5 6 10 8 7 9
   • 4 3 5 2 6 7 11 9 8 10
   • 9 7 8 10 6 5 1 4 2 3
   • 10 8 9 11 7 6 2 5 3 4
   • compilation error

3. What happens when you attempt to compile and run the following code?

   #include <vector>
   #include <iostream>
   #include <algorithm>
   using namespace std;
   class B { int val;
   public:
   B(int v):val(v){}
   int getV() const {return val;} bool operator < (const B & v) const { return val<v.val;} };
   ostream & operator <<(ostream & out, const B & v) { out<<v.getV(); return out;}
   template<class T>struct Out {
   ostream & out;
   Out(ostream & o): out(o){}
   void operator() (const T & val ) { out<<val<<” “; } };

   int main() {
   B t1[]={3,2,4,1,5};
   B t2[]={5,6,8,2,1};
   vector<B> v1(10,0);
   sort(t1, t1+5);
   sort(t2, t2+5);
   set_symmetric_difference(t2,t2+5,t1,t1+5,v1.begin());
   for_each(v1.begin(), v1.end(), Out<B>(cout));cout<<endl;
   return 0;
   }

   Program outputs:

   • 6 8 3 4 0 0 0 0 0 0
   • 3 4 0 0 0 0 0 0 0 0
   • 6 8 0 0 0 0 0 0 0 0
   • compilation error
   • 3 4 6 8 0 0 0 0 0 0

4. What happens when you attempt to compile and run the following code?

   #include <deque>
   #include <iostream>
   #include <algorithm>
   using namespace std;
   class B { int val;
   public:
   B(int v):val(v){}
   int getV() const {return val;} bool operator < (const B & v) const { return val<v.val;} };
   ostream & operator <<(ostream & out, const B & v) { out<<v.getV(); return out;}
   template<class T>struct Out {
   ostream & out;
   Out(ostream & o): out(o){}
   void operator() (const T & val ) { out<<val<<” “; } };
   int main() {
   int t[]={8, 10, 5, 1, 4, 6, 2, 7, 9, 3};
   deque<B> d1(t, t+10);
   sort(d1.begin(), d1.end());
   deque<B>::iterator it = upper_bound(d1.begin(), d1.end(), B(4));
   for_each(it, d1.end(), Out<B>(cout)); cout<<endl;
   return 0;
   }

   Program outputs:

   • 5 6 7 8 9 10
   • 4 5 6 7 8 9 10
   • 6 7 8 9 10
   • 1 2 3 4 5
   • 1 2 3 4

5. What happens when you attempt to compile and run the following code?

   #include <vector>
   #include <iostream>
   #include <algorithm>
   #include <functional>
   using namespace std;
   template<class T>struct Out {
   ostream & out;
   Out(ostream & o): out(o){}
   void operator() (const T & val ) { out<<val<<” “; } };

   int Add(int a, int b) {
   return a+b;
   }

   int main() {
   int t[]={1,2,3,4,5,6,7,8,9,10};
   vector<int> v1(t, t+10);
   vector<int> v2(10);
   transform(v1.begin(), v1.end(), v2.begin(), bind2nd(ptr_fun (Add),1));
   vector<int>::iterator it = find_if(v2.begin(), v2.end(),bind2nd(equal_to<int>(),10));
   cout<<*it<<endl;
   return 0;
   }

   Program outputs:

   • false
   • true
   • 10
   • 0
   • compilation error

6. What happens when you attempt to compile and run the following code?

   #include <iostream>
   #include <set>
   #include <list>
   using namespace std;
   int main(){
   int t[] ={ 1, 1, 2, 2, 3, 3, 4, 4, 5, 5 };
   list<int>v(t, t+10);
   set<int> s1(v.begin(),v.end());
   if (s1.count(3) == 2) {
   s1.erase(3);
   }
   for(set<int>::iterator i=s1.begin();i!= s1.end(); i++) {
   cout<<*i<<” “;
   }
   return 0;
   }

   • program outputs: 1 2 3 4 5
   • program outputs: 1 2 4 5
   • program outputs: 1 1 2 2 3 4 4 5 5
   • program outputs: 1 1 2 3 3 4 4 5 5
   • compilation error

7. What happens when you attempt to compile and run the following code?

   #include <iostream>
   #include <algorithm>
   #include <vector>
   #include <set>
   using namespace std;

   void myfunction(int i) {
   cout << ” ” << i;
   }

   int main() {
   int t[] = { 10, 5, 9, 6, 2, 4, 7, 8, 3, 1 };
   set<int> s1(t, t+10);
   vector<int> v1(s1.rbegin(), s1.rend());
   swap_ranges(s1.begin(), s1.end(), v1.begin());
   for_each(v1.begin(), v1.end(), myfunction);
   for_each(s1.begin(), s1.end(), myfunction);
   return 0;
   }

   Program outputs:

   • 10 9 8 7 6 5 4 3 2 1 1 2 3 4 5 6 7 8 9 10
   • compilation error
   • 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10
   • 1 2 3 4 5 6 7 8 9 10 10 9 8 7 6 5 4 3 2 1
   • 10 9 8 7 6 5 4 3 2 1 10 9 8 7 6 5 4 3 2 1

8. What happens when you attempt to compile and run the following code?

   #include <iostream>
   #include <algorithm>
   #include <vector>
   #include <deque>
   using namespace std;

   void myfunction(int i) {
   cout << ” ” << i;
   }

   int main() {
   int t[] = { 10, 5, 9, 6, 2, 4, 7, 8, 3, 1 };
   deque<int> d1(t, t+10);
   vector<int> v1(d1.rbegin(), d1.rend());
   sort(d1.begin(), d1.end());
   swap_ranges(v1.begin(), v1.end(), d1.begin());
   for_each(v1.begin(), v1.end(), myfunction);
   for_each(d1.begin(), d1.end(), myfunction);
   return 0;
   }

   Program outputs:

   • 10 9 8 7 6 5 4 3 2 1 1 2 3 4 5 6 7 8 9 10
   • compilation error
   • 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10
   • 1 2 3 4 5 6 7 8 9 10 1 3 8 7 4 2 6 9 5 10
   • 1 3 8 7 4 2 6 9 5 10 1 2 3 4 5 6 7 8 9 10

9. What will happen when you attempt to compile and run the code below, assuming that you enter the following sequence: 1 2 3 end<enter>?

   #include <iostream>
   #include <string>
   #include <list>
   #include <algorithm>

   using namespace std;

   template<class T>struct Out {
   ostream & out;
   Out(ostream & o): out(o){}
   void operator() (const T & val ) {out<<val<<” “; } };

   int main ()
   {
   list<int> l;
   for( ; !cin.bad() ; )
   {
   int i;
   cin>>i;
   l.push_back(i);
   }
   for_each(l.begin(), l.end(), Out<int>(cout));
   return 0;
   }

   Program will output:

   • 1 2 3
   • 1 2 3 end
   • 1
   • compilation error
   • program runs forever without output

10. What happens when you attempt to compile and run the following code?

    #include <vector>
    #include <iostream>
    #include <algorithm>
    using namespace std;
    template<class T>struct Out {
    ostream & out;
    Out(ostream & o): out(o){}
    void operator() (const T & val ) { out<<val<<” “; } };

    int main() {
    int t[]={3,2,4,1,5,10,9,7,8,6};
    vector<int> v1(t,t+10);
    sort(v1.begin(), v1.end(), greater<int>());
    cout<<min_element(v1.begin(), v1.end());
    return 0;
    }

    Program outputs:

    • 3
    • 1
    • 6
    • 10
    • compilation error

11. What happens when you attempt to compile and run the following code?

    #include <vector>
    #include <iostream>
    #include <algorithm>
    using namespace std;
    template<class T>struct Out {
    ostream & out;
    Out(ostream & o): out(o){}
    void operator() (const T & val ) { out<<val<<” “; } };

    int main() {
    int t1[]={3,2,4,1,5};
    int t2[]={5,6,8,2,1};
    vector<int> v1(10);
    sort(t1, t1+5);
    sort(t2, t2+5);
    set_union(t1,t1+5,t2,t2+5,v1.begin());
    for_each(v1.begin(), v1.end(), Out<int>(cout));cout<<endl;
    return 0;
    }

    Program outputs:

    • 3 2 4 1 5 6 8 2 1 0
    • 1 2 3 4 5 6 8 2 1 0
    • 1 1 2 2 3 4 5 5 6 8
    • 1 2 3 4 5 6 8 0 0 0
    • compilation error

12. What happens when you attempt to compile and run the following code?

    #include <vector>
    #include <iostream>
    #include <algorithm>
    using namespace std;
    class B { int val;
    public:
    B(int v):val(v){}
    int getV() const {return val;} bool operator < (const B & v) const { return val<v.val;} };
    ostream & operator <<(ostream & out, const B & v) { out<<v.getV(); return out;}
    template<class T>struct Out {
    ostream & out;
    Out(ostream & o): out(o){}
    void operator() (const T & val ) { out<<val<<” “; } };
    int main() {
    int t[]={8, 10, 5, 1, 4, 6, 2, 7, 9, 3};
    vector<B> v1(t, t+10);
    sort(v1.begin(), v1.end(), greater<B>());
    for_each(v1.begin(), v1.end(), Out<B>(cout));cout<<endl;
    return 0;
    }

    Program outputs:

    • 8 10 5 1 4 6 2 7 9 3
    • 1 2 3 4 5 6 7 8 9 10
    • compilation error
    • 10 9 8 7 6 5 4 3 2 1

13. What will happen when you attempt to compile and run the code below, assuming that you enter the following sequence: true false<enter>?

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

    int main ()
    {
    bool a,b;
    cin>>boolalpha>>a>>b;
    cout<<a<<b<<endl;
    return 0;
    }

    Program will output:

    • truefalse
    • true0;
    • 1false
    • 10
    • none of these

14. What happens when you attempt to compile and run the following code?

    #include <iostream>
    #include <algorithm>
    #include <deque>
    #include <vector>
    using namespace std;
    bool identical(int a, int b) {
    return b == 2*a?true:false;
    }
    int main() {
    int t[] = {1,2,3,2,3,5,1,2,7,3,2,1,10, 4,4,5};
    int u[] = {2,4,6,4,6,10,2,4,14,6,4,2,20,8,8,5};
    vector<int> v1(t, t + 15);
    deque<int> d1(u, u + 15);

    pair<deque<int>::iterator, vector<int>::iterator > result;
    result = mismatch(d1.begin(), d1.end(), v1.begin(), identical); //Line I
    if (result.first == d1.end() && result.second == v1.end()) {//Line II
    cout<<“Identical\n”;
    } else {
    cout<<“Not identical\n”;
    }
    return 0;
    }

    Program outputs:

    • Identical
    • Not identical
    • compilation error at line marked I
    • compilation error at line marked II

15. What happens when you attempt to compile and run the following code?

    #include <iostream>

    using namespace std;

    template <class T>
    class A {
    T_v;
    public:
    A() {}
    A(T v): _v(v){}
    friend ostream & operator<<(ostream & c, const A<T> & v);
    };

    template <class T>
    ostream & operator<<(ostream & c, const A<T> & v) {
    c<<v._v;return c; }

    int main()
    {
    A<int>a(10);
    cout<<a<<endl;
    return 0;
    }

    • program will display:10
    • program will not compile
    • program will compile
    • program will run without output

16. What happens when you attempt to compile and run the following code?

    #include <deque>
    #include <iostream>
    #include <algorithm>
    using namespace std;
    class B { int val;
    public:
    B(int v):val(v){} B(){}
    int getV() const {return val;} };
    ostream & operator <<(ostream & out, const B & v) { out<<v.getV(); return out;}
    template<class T>struct Out {
    ostream & out;
    Out(ostream & o): out(o){}
    void operator() (const T & val ) { out<<val<<” “; } };
    int main() {
    int t[]={8, 10, 5, 1, 4, 6, 2, 7, 9, 3};
    deque<B> d1(t, t+10);
    deque<B>::iterator it = lower_bound(d1.begin(), d1.end(), 4);
    for_each(it, d1.end(), Out<B>(cout));cout<<endl;
    return 0;
    }

    Program outputs:

    • 8 10 5 1 4 6 2 7 9 3
    • 4 5 6 7 8 9 10
    • 1 2 3 4 5 6 7 8 9 10
    • compilation error
    • 1 2 3 4

17. What happens when you attempt to compile and run the following code?

    #include <iostream>
    #include <algorithm>
    #include <vector>
    using namespace std;
    class A {
    int a;
    public:
    A(int a) : a(a) {}
    int getA() const { return a; } void setA(int a) { this?>a = a; }
    bool operator==(A & b) { return a == b.a; }
    };
    struct Compare{
    bool operator()(const A & a, const A & b) {return a.getA()==b.getA();};
    };
    int main () {
    int t[] = {1,2,3,4,5,1,2,3,4,5};
    vector<A> v (t,t+10);
    vector<A>::iterator it;
    A m1[] = {A(1), A(2), A(3)};
    it = search (v.begin(), v.end(), m1, m1+3, Compare());
    cout << “First found at position: ” << it?v.begin() << endl;
    return 0;
    }

    Program outputs:

    • First found at position: 5
    • First found at position: 0
    • First found at position: 7
    • compilation error
    • First found at position: 10

18. What happens when you attempt to compile and run the following code?

    #include <vector>
    #include <iostream>
    #include <algorithm>
    #include <functional>
    using namespace std;
    class B { int val;
    public:
    B(int v=0):val(v){}
    int getV() const {return val;}
    operator int () const { return val;} };

    template<class T>struct Out {
    ostream & out;
    Out(ostream & o): out(o){}
    void operator() (const T & val ) { out<<val<<” “; } };

    int main() {
    B t[]={3,2,4,1,5,6,10,8,7,9};
    vector<B> v1(t, t+10);
    for_each(v1.begin(), v1.end(), bind1st(plus<B>(), 1));
    for_each(v1.rbegin(), v1.rend(), Out<B>(cout));cout<<endl;
    return 0;
    }

    Program outputs:

    • 3 2 4 1 5 6 10 8 7 9
    • 4 3 5 2 6 7 11 9 8 10
    • 9 7 8 10 6 5 1 4 2 3
    • 10 8 9 11 7 6 2 5 3 4
    • compilation error

19. What happens when you attempt to compile and run the following code?

    #include <iostream>
    #include <algorithm>
    #include <map>
    using namespace std;

    void myfunction(pair<int, int> i) {
    cout << ” ” << i.first;
    }

    int main() {
    int t[] = { 10, 5, 9, 6, 2, 4, 7, 8, 3, 1 };
    map<int, int> m;
    for(int i=0; i < 10; i++) {
    m[i]=t[i];
    }

    for_each(m.begin(), m.end(), myfunction);
    return 0;
    }

    Program outputs:

    • 10 5 9 6 2 4 7 8 3 1
    • 0 1 2 3 4 5 6 7 8 9
    • 9 8 7 6 5 4 3 2 1 0
    • 1 3 8 7 4 2 6 9 5 10
    • compilation error

20. What happens when you attempt to compile and run the following code?

    #include <vector>
    #include <set>
    #include <iostream>
    #include <algorithm>
    using namespace std;
    template<class T>struct Out {
    ostream & out;
    Out(ostream & o): out(o){}
    void operator() (const T & val ) { out<<val<<” “; } };
    struct Sequence {
    int start;
    Sequence(int start):start(start){}
    int operator()() { return start++; } };

    int main() {
    vector<int> v1(10);
    generate_n(v1.begin(), 10, Sequence(1));
    random_shuffle(v1.rbegin(), v1.rend());
    sort(v1.begin(), v1.end(), great<int>());
    for_each(v1.begin(), v1.end(), Out<int>(cout));cout<<endl;
    return 0;
    }

    Program outputs:

    • 8 10 5 1 4 6 2 7 9 3
    • 1 2 3 4 5 6 7 8 9 10
    • compilation error
    • 10 9 8 7 6 5 4 3 2 1