Lab 4: Name mangling, template and explicit keyword

• Name mangling
  1. Create a C file named foo.c as below:

       #include <stdio.h>
     
       void foo(void) {
           printf("This is foo!\n");
       }
       

  2. Compile foo.c to its object code:

       $ gcc -c foo.c
       

  3. Create a C++ program, main.cc, in which foo() is called.

       void foo(void);
     
       int main(void) {
           foo();
           return (0);
       }
       

  4. Compile main.cc to its object code:

       $ g++ -c main.c
       

  5. Link main.o and foo.o to its executable main:

       $ g++ main.o foo.o -o main
       

  6. Explain why it wouldn't work. How would you fix it? Hint: use nm to look at main.o and foo.o.
• Template
  1. Create a C++ program named min.cc as below:

       template<class T>
       const T &min(const T &a, const T &b) {
           return (a < b ? a : b);
       }
     
       int main(void) {
           min(1, 2);
           min(1.0, 2.0);
           min('1', '2');
           return (0);
       }
       

  2. Compile min.cc and use nm to find out how many min() functions are created in the executable.

       $ g++ min.cc -o min
       $ nm min
       

• explicit keyword
  1. Create explicit.cc as below:

       #include <stdio.h>
     
       class String {
       public:
           String(int n) {
               printf("A\n");
           }
           String(const char *s) {
               printf("B\n");
           }
       };
     
       int main(void) {
           String s = 'a';  // implicit conversion for single argument constructor
       }
       

  2. Compile and run the code:

       $ g++ explicit.cc -o explicit
       $ explicit
       

  3. Explain the output.
  4. Added explicit in front of the first constructor, recompile again and see what happens.