What is dynamic initialization of objects in c++?
Please explain with an simple example...
-
14@Downvoters: What is wrong the question?Sarfaraz Nawaz– Sarfaraz Nawaz2011-05-10 06:22:23 +00:00Commented May 10, 2011 at 6:22
-
2Its textbook nature, I presume.Seva Alekseyev– Seva Alekseyev2012-09-23 18:22:36 +00:00Commented Sep 23, 2012 at 18:22
Add a comment
|
4 Answers
Dynamic initialization is that in which initialization value isn't known at compile-time. It's computed at runtime to initialize the variable.
Example,
int factorial(int n)
{
if ( n < 0 ) return -1; //indicates input error
else if ( n == 0 ) return 1;
else return n * factorial(n-1);
}
int const a = 10 ; //static initialization
//10 is known at compile time. Its 10!
int const b = factorial(8); //dynamic initialization
//factorial(8) isn't known at compile time,
//rather it's computed at runtime.
That is, static-initialization usually involves constant-expression (which is known at compile-time), while dynamic-initialization involves non-constant expression.
static int c;//this is also static initialization (with zero)!
§3.6.2/1 from the C++ Standard (2003) says,
Objects with static storage duration (3.7.1) shall be zero-initialized (8.5) before any other initialization takes place. Zero-initialization and initialization with a constant expression are collectively called static initialization; all other initialization is dynamic initialization.
So there are two kind of initializations:
- Static initialization : Its either zero-initialization or initialization with a constant expression
- Any other initialization is dynamic initialization.
Also note that the same variable can be dynamically-initialized after it has been statically-initialized. For example, see this code:
int d = factorial(8);
int main()
{
}
Since d is a global variable, it has static storage. That means, according to §3.6.2.1 it's initialized to 0 at the static-initialization phase which occurs before any other initialization takes place. Then later, at runtime, it's dynamically-initialized with the value returned from the function factorial().
That means, global objects can be initialized twice: once by static initialization (which is zero-initialization) and later, at runtime, they can be dynamically-initialized.
15 Comments
Mahi
thanks nawaz.but i am a bit confused,can u do it with a small program.
Pepe
@Mahi In dynamic initialization you calculate the value of the variable at runtime. In static initialization you set it at compile-time. In the case above assume that int f() returns a random "int" then the value of b is only know at runtime and is thus dynamically initialized.
Matthieu M.
@Nawaz: note that there is an idea about super-compilation whose goal would be to run pure functions in a "late" compilation phase (actually, probably at link stage), to get even faster binaries. I don't know of any in C++ (purity isn't annotated...) but there have been various forays with Haskell.
Sarfaraz Nawaz
@DeadMG: How good the code is, is not the point here. It is not a code to be used in production. But then some people here are crazy. They want a production code as "sample" code, without even realizing that sample code is used to demonstrate other concepts.
|
Dynamic initialization means the first value assigned to the variable after memory allocation is not known at compile time, it is evaluated only at run time. for example
#include <iostream.h>
using namespace std;
int sample()
{
int x;
cin >> x;
return x;
}
const int t = sample(); //dynamic initialization
int p = sample(); //dynamic initialization
void main()
{
cout << t;
cout << p;
}
As we know that a constant can get value only once i.e. at the time of initialization. this example shows that even a global variable which is static storage if dynamically initialize by return value of a function, the first value assigned to the variable is the value returned by function, which replaces the initial default value 0 of the variable which is assigned at the time of memory allocation.
Comments
Initialization of a variable at the run time from the keyboard is known as Dynamic Initialization.
Program code:-
int a=cube(n);
In the above program code , a is a global variable to which a number n is dynamically assigned through a function cube, where cube() performs the cube of a number.
This is an example of Dynamic Initialization.
Comments
The dynamic initialization means that the initial values may be provided during run time. Even class objects can be initialized dynamically. I.e. with the values provided at run time. :-))
