What are the advantages of using a symbolic constant rather than a literal constant in c plus plus?

Answer 1

The main two I can think of:

1. It gives more meaning to the constant. eg using PI instead of 3.14159 makes it easier to understand what's going on when calculating things like a = PI * r * r;
2. Should the constant for the program need to be changed, only one occurrence needs to be changed (in a header file) instead of all usages.

Answer 2

Symbolic constants offer two benefits. The first benefit is that it is easier to remember the symbolic constant than its underlying value (such as remembering Math.PI instead of 3.14159). The second benefit is that if a value changes, you need only find the constant in its source. As an example, if you write an algorithm that operates on 256 bits (but can be variable), and you discover later that 512 bits would be optimal, you can simply change the value of the constant instead of looking for every instance of 256 and replacing it with 512 (where you might miss an instance of it, or even worse, change a 256 that was actually unrelated to the algorithm).

Answer 3

When we use literal constants, we invariably use them repeatedly in our code. However, sometimes we need to change the value of a constant at design time, thus we must search all our code and replace each and every occurrence, which may lead to inconsistencies in our code if we miss any. We could use a search and replace utility, however we might use the same constant value for different purposes and may not wish to change every occurrence, so we'd need to manually inspect each replacement. This creates a maintenance burden that we don't get when we use symbolic constants.

By assigning literal constants to a symbolic constants, we can identify constants by name rather than by value, which (with well-chosen symbolic names) helps make our code more readable. And if we need to change the value of certain symbols, we can do so in just one place; all code that uses that symbol will be updated immediately, thus ensuring consistency is maintained.

Answer 4

C has no concept of a constant variable so we must use symbolic constants instead. However, symbolic constants are not type safe:

#define PI 3.14

#define HI "Hello world"

void main() {

int pi = PI; // warning: conversion from double to int!

char c = HI; // error: string to character

return 0;

}