Engineering Online MCQ Number 0597 – online study, assignment and exam

Multiple choice question for engineering

Set 1

1. Which alternative can replace the throw statement?
a) for
b) break
c) return
d) exit

Answer

Answer: c [Reason:] throw and return does the same job like return a value. So it can be replaced.

2. What are the disadvantages if use return keyword to return error codes?
a) You have to handle all exceptional cases explicitly
b) Your code size increases dramatically
c) The code becomes more difficult to read
d) All of the mentioned

Answer

Answer: d [Reason:] As we are using return for each and every exception, It will definetly increase the code size.

3. What is most suitable for returning the logical errors in the program?
a) Use contructor and destructor
b) Set a global error indicator
c) Use break keyword
d) None of the mentioned

Answer

Answer: b

4. What is the output of this program?

```
    #include <iostream>
```
```
    #include <typeinfo>
```
```
    using namespace std;
```
```
    class A 
```
```
    { 
```
```
    };
```
```
    int main()
```
```
    { 
```
```
        char c; float x;
```
```
        if (typeid(c) != typeid(x))
```

        cout << typeid(c).name() << endl;

```
        cout << typeid(A).name();
```
```
        return 0;
```
```
    }
```

a) c
1A
b) x
c) Both c & x
d) None of the mentioned

Answer

Answer: a [Reason:] We are checking the type id of char and float as they are not equal, We are printing c.
Output:
$ g++ eal.cpp
$ a.out
c
1A

5. What is the output of this program?

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

    void Division(const double a, const double b);

```
    int main()
```
```
    {
```
```
        double op1=0, op2=10;
```
```
        try 
```
```
        {
```
```
            Division(op1, op2);
```
```
        }
```
```
        catch (const char* Str)
```
```
        {
```

            cout << "nBad Operator: " << Str;

```
        }
```
```
        return 0;
```
```
    }
```

    void Division(const double a, const double b)

```
    {
```
```
        double res;
```
```
        if (b == 0)
```

            throw "Division by zero not allowed";

```
        res = a / b;
```
```
        cout << res;
```
```
    }
```

a) 0
b) Bad operator
c) 10
d) None of the mentioned

Answer

Answer: a [Reason:] We are dividing 0 and 10 in this program and we are using the throw statement in the function block.
Output:
$ g++ eal.cpp
$ a.out
0

6. What is the output of this program?

```
    #include <stdexcept>
```
```
    #include <limits>
```
```
    #include <iostream>
```
```
    using namespace std;
```
```
    void MyFunc(char c)
```
```
    {
```

        if (c < numeric_limits<char>::max())

```
            return invalid_argument;
```
```
    }
```
```
    int main()
```
```
    {
```
```
        try
```
```
        {
```
```
            MyFunc(256);
```
```
        }
```
```
        catch(invalid_argument& e)
```
```
        {
```
```
            cerr << e.what() << endl;
```
```
            return -1;
```
```
        }
```
```
        return 0;
```
```
    }
```

a) 256
b) Invalid argument
c) Error
d) None of the mentioned

Answer

Answer: c [Reason:] We can’t return a statement by using the return keyword, So it is arising an error.

7. What is the use of RAII in c++ programing?
a) Improve the exception safety
b) Terminate the program
c) Exit from the block
d) None of the mentioned

Answer

Answer: a

8. How many levels are there in exception safety?
a) 1
b) 2
c) 3
d) 4

Answer

Answer: c [Reason:] The three levels of exception safety are basic, strong and nothrow.

9. Pick out the correct statement for error handling alternatives.
a) Terminate the program
b) Use the stack
c) Exit from the block
d) None of the mentioned

Answer

Answer: b [Reason:] When an error is arised means, it will be pushed into stack and it can be corrected later by the programmer.

10. What will happen when an exception is not processed?
a) It will eat up lot of memory and program size
b) Terminate the program
c) Crash the compiler
d) None of the mentioned

Answer

Answer: a [Reason:] As in the case of not using an exception, it will remain useless in the program and increase the code complexity.

Set 2

1. What is a function template?
a) creating a function without having to specify the exact type
b) creating a function with having a exact type
c) all of the mentioned
d) none of the mentioned

Answer

Answer: a

2. Which is used to describe the function using placeholder types?
a) template parameters
b) template type parameters
c) template type
d) none of the mentioned

Answer

Answer: b [Reason:] During runtime, We can choose the appropriate type for the function
and it is called as template type parameters.

3. Pick out the correct statement.
a) you only need to write one function, and it will work with many different types
b) it will take a long time to execute
c) duplicate code is increased
d) none of the mentioned

Answer

Answer: a [Reason:] Because of template type parameters, It will work with many types and saves a lot of time.

4. What is the output of this program?

```
    #include <iostream>
```
```
    using namespace std;
```
```
    template<typename type>
```
```
    type Max(type Var1, type Var2)
```
```
    {
```
```
        return Var1 > Var2 ? Var1:Var2;
```
```
    }
```
```
    int main()
```
```
    {
```
```
        int p;
```
```
        p = Max(100, 200);
```
```
        cout << p << endl;
```
```
        return 0;
```
```
    }
```

a) 100
b) 200
c) 300
d) 100200

Answer

Answer: b [Reason:] In this program, We are returning the maximum value by using function template.
Output:
$ g++ ftemp.cpp
$ a.out
200

5. What is the output of this program?

```
    #include <iostream>
```
```
    using namespace std;
```
```
    template<typename type> 
```
```
    class Test
```
```
    {
```
```
        public:
```
```
        Test()
```
```
        {
```
```
        };
```
```
        ~Test()
```
```
        {
```
```
        };
```
```
        type Funct1(type Var1)
```
```
        {
```
```
            return Var1;
```
```
        }
```
```
        type Funct2(type Var2)
```
```
        {
```
```
            return Var2;
```
```
        }
```
```
    };
```
```
    int main()
```
```
    {
```
```
        Test<int> Var1;
```
```
        Test<float> Var2;
```

        cout << Var1.Funct1(200) << endl;

        cout << Var2.Funct2(3.123) << endl;

```
        return 0;
```
```
    }
```

a) 200
3.123
b) 3.123
200
c) 200
d) 3.123

Answer

Answer: a [Reason:] In this program, We are passing the values and getting it back from template. And we are using the constructor and destructor for the function template.
Output:
$ g++ ftemp1.cpp
$ a.out
200
3.123

6. What is the output of this program?

```
    #include <iostream>
```
```
    using namespace std;
```
```
    template<typename type>
```
```
    class TestVirt
```
```
    {
```
```
        public:
```

        virtual type TestFunct(type Var1)

```
        {
```
```
            return Var1 * 2;
```
```
        }
```
```
    };
```
```
    int main()
```
```
    {
```
```
        TestVirt<int> Var1;
```

        cout << Var1.TestFunct(100) << endl;

```
        return 0;
```
```
    }
```

a) 100
b) 200
c) 50
d) none of the mentioned

Answer

Answer: b [Reason:] In this program, We are using class to pass the value and then we are manipulating it.
Output:
$ g++ ftemp3.cpp
$ a.out
200

7. What is the output of this program?

```
    #include <iostream>
```
```
    using namespace std;
```
```
    template<typename T> 
```
```
    inline T square(T x)
```
```
    {
```
```
        T result;
```
```
        result = x * x;
```
```
        return result;
```
```
    };
```
```
    int main()
```
```
    {
```
```
        int i, ii;
```
```
        float x, xx;
```
```
        double y, yy;
```
```
        i = 2;
```
```
        x = 2.2;
```
```
        y = 2.2;
```
```
        ii = square(i);
```

        cout << i << " "  << ii << endl;

```
        yy = square(y);
```
```
        cout << y << " " << yy << endl;
```
```
    }
```

a) 2 4
2.2 4.84
b) 2 4
c) error
d) runtime error

Answer

Answer: a [Reason:] In this program, We are passing the values and calculating the square of the value by using the function template.
Output:
$ g++ ftemp4.cpp
$ a.out
2 4
2.2 4.84

8. What is the output of this program?

```
    #include <iostream>
```
```
    using namespace std;
```
```
    template<typename T> 
```
```
    void loopIt(T x)
```
```
    {
```
```
        int count = 3;
```
```
        T val[count];
```

        for (int ii=0; ii < count; ii++)

```
        {
```
```
            val[ii] = x++;
```
```
            cout <<  val[ii] << endl;
```
```
        }
```
```
    };
```
```
    int main()
```
```
    {
```
```
        float xx = 2.1;
```
```
        loopIt(xx);
```
```
    }
```

a) 2.1
b) 3.1
c) 3.2
d) 2.1
3.1
4.1

Answer

Answer: d [Reason:] In this program, We are using the for loop to increment the value by 1 in the function template.
Output:
$ g++ ftemp5.cpp
$ a.out
2.1
3.1
4.1

9. What can be passed by non-type template parameters during compile time?
a) int
b) float
c) constant expression
d) none of the mentioned

Answer

Answer: c [Reason:] Non-type template parameters provide the ability to pass a constant expression at compile time. The constant expression may also be an address of a function, object or static class member.

10. From where does the template class derived?
a) regular non-templated C++ class
b) templated class
c) regular non-templated C++ class or templated class
d) none of the mentioned

Answer

Answer: c

Set 3

1. What is meant by multiple inheritance?
a) Deriving a base class from derived class
b) Deriving a derived class from base class
c) Deriving a derived class from more than one base class
d) None of the mentioned

Answer

Answer: c [Reason:] Multiple inheritance enables a derived class to inherit members from more than one parent.

2. Which symbol is used to create multiple inheritance?
a) Dot
b) Comma
c) Dollar
d) None of the mentioned

Answer

Answer: b [Reason:] For using multiple inheritance, simply specify each base class (just like in single inheritance), separated by a comma.

3. Which of the following advantages we lose by using multiple inheritance?
a) Dynamic binding
b) Polymorphism
c) Both Dynamic binding & Polymorphism
d) None of the mentioned

Answer

Answer: c [Reason:] The benefit of dynamic binding and polymorphism is that they help making the code easier to extend but by multiple inheritance it makes harder to track.

4. What is the output of this program?

```
    #include <iostream>
```
```
    using namespace std;
```
```
    class polygon 
```
```
    {
```
```
        protected:
```
```
        int width, height;
```
```
        public:
```
```
        void set_values (int a, int b)
```
```
        { 
```
```
            width = a; height = b;}
```
```
        };
```
```
        class output1 
```
```
        {
```
```
            public:
```
```
                void output (int i);
```
```
        };
```
```
    void output1::output (int i) 
```
```
    {
```
```
        cout << i << endl;
```
```
    }
```

    class rectangle: public polygon, public output1

```
    {
```
```
        public:
```
```
        int area ()
```
```
        { 
```
```
            return (width * height); 
```
```
        }
```
```
    };
```

    class triangle: public polygon, public output1

```
    {
```
```
        public:
```
```
        int area ()
```
```
        {
```

            return (width * height / 2);

```
        }
```
```
    };
```
```
    int main () 
```
```
    {
```
```
        rectangle rect;
```
```
        triangle trgl;
```
```
        rect.set_values (4, 5);
```
```
        trgl.set_values (4, 5);
```
```
        rect.output (rect.area());
```
```
        trgl.output (trgl.area());
```
```
        return 0;
```
```
    }
```

a) 20
b) 10
c) 20
10
d) None of the mentioned

Answer

Answer: c [Reason:] We are using the multiple inheritance to find the area of rectangle and triangle.
Output:
$ g++ mul.cpp
$ a.out
20
10

5. What is the output of this program?

```
    #include <iostream>
```
```
    using namespace std;
```
```
    class Base
```
```
    {
```
```
        public:
```
```
        virtual void print() const = 0;
```
```
    };
```
```
    class DerivedOne : public Base
```
```
    {
```
```
        public:     
```
```
        void print() const
```
```
        {
```
```
            cout << "DerivedOnen";
```
```
        }
```
```
    };
```
```
    class DerivedTwo : public Base
```
```
    {
```
```
        public:
```
```
        void print() const
```
```
        {
```
```
            cout << "DerivedTwon";
```
```
        }     
```
```
    }; 
```

    class Multiple : public DerivedOne, public DerivedTwo

```
    {
```
```
        public:
```
```
        void print() const
```
```
        {
```
```
            DerivedTwo :: print();
```
```
        } 
```
```
    }; 
```
```
    int main()
```
```
    {
```
```
        int i;
```
```
        Multiple both; 
```
```
        DerivedOne one; 
```
```
        DerivedTwo two; 
```
```
        Base *array[ 3 ]; 
```
```
        array[ 0 ] = &both; 
```
```
        array[ 1 ] = &one;
```
```
        array[ 2 ] = &two;
```
```
        array[ i ] -> print();
```
```
        return 0;
```
```
    }
```

a) DerivedOne
b) DerivedTwo
c) Error
d) None of the mentioned

Answer

Answer: c [Reason:] In this program, ‘Base’ is an ambiguous base of ‘Multiple’. So it is producing an error. And this program is a virtual base class.

6. What is the output of this program?

```
    #include <iostream>
```
```
    using namespace std;
```
```
    class student
```
```
    {
```
```
        public:
```
```
        int rno , m1 , m2 ;
```
```
        void get()
```
```
        {
```
```
            rno = 15, m1 = 10, m2 = 10;
```
```
        }
```
```
    };
```
```
    class sports
```
```
    {
```
```
        public:
```
```
        int sm;
```
```
        void getsm()
```
```
        {
```
```
            sm = 10;
```
```
        }
```
```
    };
```

    class statement:public student,public sports

```
    {
```
```
        int tot,avg;
```
```
        public:
```
```
        void display()
```
```
        {
```
```
            tot = (m1 + m2 + sm);
```
```
            avg = tot / 3;
```
```
            cout << tot;
```
```
            cout << avg;
```
```
        }
```
```
    };
```
```
    int main()
```
```
    {
```
```
        statement obj;
```
```
        obj.get();
```
```
        obj.getsm();
```
```
        obj.display();
```
```
    }
```

a) 3100
b) 3010
c) 2010
d) 1010

Answer

Answer: b [Reason:] In this program, We are calculating the total and average marks of a student by using multiple inheritance.
Output:
$ g++ mul1.cpp
$ a.out
3010

7. What is the output of this program?

```
    #include <iostream>
```
```
    using namespace std;
```
```
    struct a
```
```
    {
```
```
        int count;
```
```
    };
```
```
    struct b
```
```
    {
```
```
        int* value;
```
```
    };
```
```
    struct c : public a, public b
```
```
    {
```
```
    };
```
```
    int main()
```
```
    {
```
```
        c* p = new c;
```
```
        p->value = 0;
```
```
        cout << "Inherited";
```
```
        return 0;
```
```
    }
```

a) Inherited
b) Error
c) Runtime error
d) None of the mentioned

Answer

Answer: a [Reason:] In this program, We apply the multiple inheritance to structure.
Output:
$ g++ mul2.cpp
$ a.out
Inherited

8. What is the output of this program?

```
    #include <iostream>
```
```
    using namespace std;
```
```
    class Base1
```
```
    {
```
```
        protected:
```
```
        int SampleDataOne;
```
```
        public:
```
```
        Base1()
```
```
        {
```
```
            SampleDataOne = 100;
```
```
        }
```
```
        ~Base1()
```
```
        {
```
```
        }
```
```
        int SampleFunctOne()
```
```
        {
```
```
            return SampleDataOne;
```
```
        }
```
```
    };
```
```
    class Base2
```
```
    {
```
```
        protected:
```
```
        int SampleDataTwo;
```
```
        public:
```
```
        Base2()
```
```
        {
```
```
            SampleDataTwo = 200;
```
```
        }
```
```
        ~Base2()
```
```
        {
```
```
        }
```
```
        int SampleFunctTwo()
```
```
        {
```
```
            return SampleDataTwo;
```
```
        }
```
```
    };
```

    class Derived1 : public Base1, public Base2

```
    {
```
```
        int MyData;
```
```
        public:
```
```
        Derived1() 
```
```
        {
```
```
            MyData = 300;
```
```
        }
```
```
        ~Derived1()
```
```
        {
```
```
        }    
```
```
        int MyFunct()
```
```
        {
```

            return (MyData + SampleDataOne + SampleDataTwo);

```
        }
```
```
    };
```
```
    int main()
```
```
    {
```
```
        Base1 SampleObjOne;
```
```
        Base2 SampleObjTwo;
```
```
        Derived1 SampleObjThree;
```

        cout << SampleObjThree.Base1 :: SampleFunctOne() << endl;

        cout << SampleObjThree.Base2 :: SampleFunctTwo() << endl;

```
        return 0;
```
```
    }
```

a) 100
b) 200
c) Both 100 & 200
d) None of the mentioned

Answer

Answer: c [Reason:] In this program, We are passing the values by using multiple inheritance and printing the derived values.
Output:
$ g++ mul4.cpp
$ a.out
100
200

9. Which design patterns benefit from the multiple inheritance?
a) Adapter and observer pattern
b) Code pattern
c) Glue pattern
d) None of the mentioned

Answer

Answer: a

10. What are the things are inherited from the base class?
a) Constructor and its destructor
b) Operator=() members
c) Friends
d) All of the mentioned

Answer

Answer: d [Reason:] These things can provide necessary information for the base class to make a logical decision.

Set 4

1. What will happen when an exception is uncaught?
a) arise an error
b) program will run
c) exceute continuously
d) none of the mentioned

Answer

Answer: a

2. Which handler is used to handle all types of exception?
a) catch handler
b) catch-all handler
c) catch-none hendler
d) none of the mentioned

Answer

Answer: b [Reason:] To catch all types of exceptions, we use catch-all handler.

3. Which operator is used in catch-all handler?
a) ellipses operator
b) ternary operator
c) string operator
d) unary operator

Answer

Answer: a [Reason:] The ellipses operator can be represented as (…).

4. What is the output of this program?

```
    #include <iostream>
```
```
    using namespace std;
```
```
    class Base
```
```
    {
```
```
        protected:
```
```
        int a;
```
```
        public:
```
```
        Base() 
```
```
        { 
```
```
            a = 34; 
```
```
        }
```
```
        Base(int i)
```
```
        { 
```
```
            a = i; 
```
```
        }
```
```
        virtual ~Base() 
```
```
        { 
```
```
            if (a < 0)  throw a; 
```
```
        }
```
```
        virtual int getA()
```
```
        {
```
```
            if (a < 0) 
```
```
            { 
```
```
                throw a;
```
```
            }
```
```
        }
```
```
    };
```
```
    int main()
```
```
    {
```
```
        try
```
```
        {
```
```
            Base b(-25);
```
```
            cout << endl << b.getA();
```
```
        }
```
```
        catch (int) 
```
```
        {
```

            cout << endl << "Illegal initialization";

```
        }
```
```
    }
```

a) Illegal initialization
b) Terminate called after throwing an instance of ‘int’
c) Illegal initialization & terminate called after throwing an instance
d) None of the mentioned

Answer

Answer: b [Reason:] As we are throwing an negative number and we are using only integer, So it is arising an error.
Output:
$ g++ uce.cpp
$ a.out
terminate called after throwing an instance of ‘int’

5. What is the output of this program?

```
    #include <iostream>
```
```
    #include <exception>
```
```
    using namespace std;
```
```
    void terminator()
```
```
    {
```
```
        cout << "terminate" << endl;
```
```
    }
```

    void (*old_terminate)() = set_terminate(terminator);

```
    class Botch 
```
```
    {
```
```
        public:
```
```
        class Fruit {};
```
```
        void f() 
```
```
        {
```
```
            cout << "one" << endl;
```
```
            throw Fruit();
```
```
        }
```
```
        ~Botch() 
```
```
        {
```
```
            throw 'c'; 
```
```
        }
```
```
    };
```
```
    int main() 
```
```
    {
```
```
        try 
```
```
        {
```
```
            Botch b;
```
```
            b.f();
```
```
        } 
```
```
        catch(...) 
```
```
        {
```

            cout << "inside catch(...)" << endl;

```
        }
```
```
    }
```

a) one
b) inside catch
c) one
terminate
d) one
terminate
Aborted

Answer

Answer: d [Reason:] This program uses set_terminate as it is having an uncaught exception.
Output:
$ g++ uce1.cpp
$ a.out
one
terminate
Aborted

6. What is the output of this program?

```
    #include <iostream>
```
```
    #include <exception>
```
```
    #include <cstdlib>
```
```
    using namespace std;
```
```
    void myterminate () 
```
```
    {
```

        cerr << "terminate handler called";

```
        abort();
```
```
    }
```
```
    int main (void) 
```
```
    {
```
```
        set_terminate (myterminate);
```
```
        throw 0; 
```
```
        return 0;
```
```
    }
```

a) terminate handler called
b) aborted
c) both terminate handler & Aborted
d) none of the mentioned

Answer

Answer: c [Reason:] In this program, We are using set_terminate to abort the program.
Output:
$ g++ uce2.cpp
$ a.out
terminate handler called
Aborted

7. What is the output of this program?

```
    #include <iostream>
```
```
    using namespace std;
```
```
    class Test1 
```
```
    { 
```
```
    };
```
```
    class Test2 : public Test1 { };
```
```
    void Funct();
```
```
    int main()
```
```
    {
```
```
        try
```
```
        {
```
```
            Funct();
```
```
        }
```
```
        catch (const Test1&)
```
```
        {
```

            cerr << "Caught a exception" << endl;

```
        }
```
```
        return 0;
```
```
    }
```
```
    void Funct()
```
```
    {
```
```
        throw Test2();
```
```
    }
```

a) Caught an exception
b) NULL
c) Both Caught an exception & NULL
d) None of the mentioned

Answer

Answer: a [Reason:] In this program, We are arising the exception by using the method in the class.
Output:
$ g++ uce3.cpp
$ a.out
Caught a exception

8. What is the output of this program?

```
    #include <iostream>
```
```
    using namespace std;
```
```
    #include <cstdlib>
```
```
    #include <exception>
```
```
    void Funct()
```
```
    {
```

        cout << "Funct() was called by terminate()." << endl;

```
        exit(0);
```
```
    }
```
```
    int main()
```
```
    {
```
```
        try
```
```
        {
```
```
            set_terminate(Funct);
```
```
            throw "Out of memory!";
```
```
        }
```
```
        catch(int)
```
```
        { 
```

            cout << "Integer exception raised." << endl;

```
        }
```
```
        return 0;
```
```
    }
```

a) Integer exception raised
b) Funct() was called by terminate()
c) Integer exception not raised
d) none of the mentioned

Answer

Answer: b [Reason:] As there is no integer in this program, We are printing Funct() was called by terminate().
Output:
$ g++ uce4.cpp
$ a.out
Funct() was called by terminate().

9. What function will be called when we have a uncaught exception?
a) catch
b) throw
c) terminate
d) none of the mentioned

Answer

Answer: c [Reason:] If we have an uncaught exception means, compiler will throw the control of program to terminate function.

10. What will not be called when the terminate() is arised in constructor?
a) main()
b) class
c) destructor
d) none of the mentioned

Answer

Answer: c

Set 5

1. What is intravenous injection?
a) It is administered in the muscle
b) It is administered under the skin
c) It is the administration of medication to a cow via the blood vessels
d) It requires the tented method

Answer

Answer: c [Reason:] Some medications must be given by an intravenous (IV) injection or infusion. This means they’re sent directly into your vein using a needle or tube. With IV administration, a thin plastic tube called an IV catheter is inserted into your vein.

2. What is intra muscular injection?
a) It is administered in the muscle
b) It is administered under the skin
c) It is the administration of medication to a cow via the blood vessels
d) It requires the tented method

Answer

Answer: a [Reason:] An intramuscular injection is a technique used to deliver a medication deep into the muscles. You may have received an intramuscular injection at a doctor’s office the last time you got a vaccine, like the flu shot.

3. What is subcutaneous injection?
a) It is administered in the muscle
b) It is administered under the skin
c) It is the administration of medication to a cow into the blood vessels
d) It requires the tented method

Answer

Answer: b [Reason:] A subcutaneous injection is administered as a bolus into the subcutis, the layer of skin directly below the dermis and epidermis, collectively referred to as the cutis. Subcutaneous injections are highly effective in administering vaccines and medications such as insulin, morphine, diacetylmorphine and goserelin.

4. Regarding feed formulation, what does CAD stand for?
a) Cation-Anion Degree
b) Cation-Anion Difference
c) Cation-Amonia Difference
d) Carbohydrate- Amino Degradation

Answer

Answer: b [Reason:] Dietary cation-anion difference, or DCAD, is a measure you should be using in both dry and lactating cows. In close-up dry cows, a negative (-ve ) DCAD helps to prevent metabolic problems and in lactating cows, a positive DCAD can help increase milk production and milk components.

5. What is a cation?
a) A negatively charged ion
b) A uncharged ion
c) A positively charged electron
d) A positively charged ion

Answer

Answer: d [Reason:] Cations and anions are both ions. The difference between a cation and an anion is the net electrical charge of the ion. Ions are atoms/ molecules those who have gained or lost one or more valence electrons giving the ion a net positive or negative charge. Cations are ions with a net positive charge.

6. What is an anion?
a) A positively charged ion
b) A uncharged ion
c) A positively charged electron
d) A negatively charged ion

Answer

Answer: d [Reason:] Anions are atoms or radicals (groups of atoms), that have gained electrons. As they now have more of electrons than protons, anions have a negative charge.

7.What is NAFTA?
a) North American Forage Trade Association
b) North American Free Trade Agreement
c) North American Free Trade Association
d) North African Free Trade Association

Answer

Answer: b [Reason:] The North American Free Trade Agreement (NAFTA) is a piece of regulation implemented January 1, 1994 simultaneously in Mexico, Canada and the United States that eliminates most tariffs on trade between these nations.

8. What is the USAHA?
a) U S Animal Housing Association
b) U S Animal Health Award
c) U S Agriculture Health Administrator
d) U S Animal Health Association

Answer

Answer: d [Reason:] The United States Animal Health Association (USAHA), the nation’s animal health forum for over a century, is a science-based, non-profit, voluntary organization. USAHA works with state and federal governments, universities, veterinarians, livestock producers, national livestock and poultry organizations, research scientists, the extension service and several foreign countries to control livestock diseases in the United States.

9. What is the USDA’s AIPL?
a) Animal Improvement Program Library
b) Animal Import Program Liability
c) Animal Improvement Program Lab
d) Animal Import Process Language

Answer

Answer: c [Reason:] In April 2014, the Animal Improvement Programs Laboratory (AIPL) and the Bovine Functional Genomics Laboratory (BFGL) were merged to form the Animal Genomics and Improvement Laboratory (AGIL). As part of the merger, the main AIPL research project on the discovery and development of improved methods for the genetic and genomic evaluation of economically important traits of dairy animals was renamed the Animal Improvement Program (AIP).

10. How many days into a pregnancy can a fetus be sexed by ultrasound?
a) Before 14 days
b) Between 14 and 30 days
c) Between 30 and 55 days
d) Between 55 and 95

Answer

Answer: d [Reason:] At approximately day 60 of gestation, male and female genital tubercles can be visualized on a high-resolution ultrasound monitor. Male and female genital tubercles appear bilobed on the monitor; each lobe is in the shape of an oval, which aids in differentiation from surrounding structures.

11. What is another term for the lowest lateral regions of the abdomen, near the groin?
a) Gubernaculum
b) Rumen
c) Abomasum
d) Inguinal

Answer

Answer: d [Reason:] In human anatomy, the inguinal region refers to either the groin or the lower lateral regions of the abdomen. It may also refer to as a conjoint tendon, previously known as the inguinal aponeurotic falx, a structure formed from the transversus abdominis insertion into the pecten pubis.

12. How many days after breeding can a pregnancy be detected by ultrasound?
a) Between 28 to 30 days
b) Before 14 days
c) Between 14 and 28 days
d) Between 30 and 55 days

Answer

Answer: a [Reason:] After breeding pregnancy takes place. The pregnancy can be detected by ultrasound 28-30 days after the breeding.

13. At how many days can pregnancy be detected by palpation?
a) Before 14 days
b) Between 14 and 40 days
c) Between 40 to 50 days
d) Between 50 and 95 days

Answer

Answer: c [Reason:] The main advantage of scanning is that it can give an accurate diagnosis earlier than rectal palpation. Pregnancy can be detected earlier with ultrasound compared with rectal palpation. 10 to 16% of cows diagnosed pregnant at 40-50 days.

14. What structural carbohydrate component makes older plants less digestible than younger plants?
a) Lignin
b) Cellulose
c) Fructrose
d) Sucrose

Answer

Answer: a [Reason:] Lignin composition and p-coumaric acid in the wall are less likely to affect digestibility. Voluntary intake of forages is a critical determinant of animal performance and cell-wall concentration is negatively related to intake of ruminants consuming high-forage diets.

15. On average, how many weeks after freshening does a cow’s dry matter intake peak?
a) 1-2 weeks
b) 2-4 weeks
c) 12-14 weeks
d) 40-42 weeks

Answer

Answer: c [Reason:] Cows freshen after a calf’s birth. Freshening occurs when milk production begins. She’s then a “wet” cow, as opposed to “dry,” non-milk-producing animal. Bout 12-14 weeks after freshening does a cow’s dry matter intake peak.

DistPub Team

Distance Publisher (DistPub.com) provide project writing help from year 2007 and provide writing and editing help to hundreds student every year.