What are disadvantages of virtual functions in c plus plus?

Answer 1

Virtual functions have many advantages, but here are a couple of their disadvantages:

• slower -- The function call takes slightly longer due to the virtual mechanism,and it also makes it more difficult for the compiler to optimize because it doesn't know exactly which function is going to be called at compile time.
• harder to debug -- In a complex system, virtual functions can make it a little more difficult to figure out where a function is being called from. Or, to figure out why a function isn't being called if someone overrode it with a new virtual function.
  

Answer 2

A function must return a result. For it to be useful it must be part of an expression, i.e., not called as a standalone routine. For example, suppose you have a function called 'sum' that adds two numbers and returns the result.

The following code would make no sense because you don't keep the result:

sum (a, b) ;

It would be better to use it as:

result = sum (a,b) ;

Answer 3

The only disadvantage to a function is that it incurs a function call. However, simple function calls can be optimised away by the compiler if the function can be inline expanded. Usually the function needs to be simple, one or two statements at most, or one that is called infrequently. If the function is implemented at the point of declaration then it is automatically a candidate for inline expansion, otherwise you must precede the function's implementation with the inline keyword. However, declaring a function inline is no guarantee it will be inline expanded, it is merely a hint to the compiler that the function is a candidate for inline expansion. Declaring every function inline will only result in a much slower compilation and if the increased code size would be detrimental to overall performance then the compiler may decide the expense of a function call far outweighs any lost performance from inline expansion. Some compilers may allow you to force an inline expansion, but there are still certain functions that cannot be inline expanded, such as recursive functions with a depth greater than n recursions, where n is usually limited to 16. All in all it's generally best to let the compiler decide as its inline optimisers are highly advanced.

The main advantage of a function is that it helps streamline your code, making it more readable and much easier to manage. Unlike a goto statement, which branches off never to return (known as spaghetti code), a function call always returns to the caller, and can return a value if necessary (as well as returning additional values through output parameters). If you have a complex statement or series of statements that are called often then turning those statements into a function means you only have to call the function rather than continually retype the same statements over and over. Not only do you eliminate the chance of a typo, you reduce code maintenance because the code is all in one place. If you need to modify the code, you only have to do it once, rather than for every occurrence (which may lead to errors if you forget to update all occurrences).

Answer 4

The only disadvantage to a function is in actually calling the function. If the function can't be inline expanded, the overhead in making the call may be detrimental to performance and memory consumption (depending on the number and type of parameters it accepts). However, even for non-inline expanded functions, the advantage of having common code in one place rather than in several more than offsets any disadvantages incurred by making the call. Updating one function is much easier than trying to locate and edit all instances of common code. Of course, if the compiler can generate inline expanded code for a function, then so much the better. The only disadvantage is increased code size, but that's hardly a problem when the advantage is better performance.

Answer 5

Only that it's easy to get carried away writing new function signatures that may never be used in your programs. Although it can increase the flexibility of your function, there's little point in writing overloads you'll never use. Although the compiler can ignore them, you'll have wasted time writing them in the first place. Other than that, there are no disadvantages.

Note that if the only difference is the type of parameter rather than the number of parameters, function templates are a much better option. The compiler generates the overloads for you, on an as-required basis, and you've only got one function to maintain.

Answer 6

The only disadvantage to inline functions is the increased code size, which can be detrimental to performance, even with the reduced number of function calls. However, declaring a function inline is no guarantee it will be inline expanded; the compiler is free to ignore the declaration if the increased code size would prove detrimental to code performance. The only functions that are guaranteed to be inline expanded are those declared in macros, hence non-trivial macros are generally frowned upon.

Answer 7

Disadvantages of using functions in c:

1)The execution time of function is higher.

2)Recursion is the biggest problem associated with functions.

Answer 8

using function unneccessarily will slow your program down...

Answer 9

disadvantages