What is #define? I've seen people use it like #include but what does #define do?
Thanks
-Chris
#define
What is #define? I've seen people use it like #include but what does #define do?
Thanks
-Chris
hi,
#define is a preprocessor directive. In a simple term it is some thing like keyword which hints the preprocessor (the earlier phase of compilation.)
The preprocessor replaces the string which is defined with #define with its value.
That is
#define OK 1
if(m_answer == OK)
{
}
than OK will be replaced by 1 before compilation. Thus you can make your program more readable and understandable by using descriptive strings for numbers.
Also #define is used to define a macro. The macro is a small piece of code which is used more than once in the program.
Before compilation this code will be placed wherever this macro has been called.
#define SQURE(x) x*x
b=SQURE(3); // code
This code will be converted automatically to
b=3*3; //before compilation
If you make the function for this purpose. The compiler will generated many more instructions for this small function(to do sequencing purpose) , which will be negative for performance of the program.
But make sure that don't use macro for more than 2 to 3 statments of code because it doesn't make sense in terms of programming style.
Refer any C book which has covered Preprocessor directives chapter. You will get many more help for that..
Bye..
jatan ([email protected])
It's a macro. With #define you can make a word represent something, for example a number:
Here MAX is the same thing as 5. Now, say you wanted a bigger array. Say you wanted an array of 10 elements instead of 5 elements. In that case the only code that you would have to change in your program would be:Code:#define MAX 5 int main() { int array[MAX]; for(int i=0; i< MAX; i++) { array[i] = i; printf("array[%d] = %d", array[i],array[i]); } return 0; }
#define MAX 10
I compile code with:
Visual Studio.NET beta2
but that looks just like a declaration of a variable but without the type (int, double ect.)
Is there anything difference?
Variables take up space in your program at run time. Items which have been defined using #define are processed by the pre-processor at compile time, hence use no resources at run time.
Wave upon wave of demented avengers march cheerfully out of obscurity unto the dream.
Sure there is a difference, it is faster due to Adrians explanation, and also if you had to use a variable to represent something such as:but that looks just like a declaration of a variable but without the type (int, double ect.)
Is there anything difference?
That varable can accidently get changed during calculations due to human error unless you wrote:Code:double Pie = 3.14;
Another thing is that it has global scope. It can be used in any function and does not have to be passed as an arguement. It can make your program easier to read too. It's more organized. But other than that, it's nothing special.Code:const double Pie = 3.14;
I compile code with:
Visual Studio.NET beta2
Use of define is not encouraged as much in C++ as it is in C due to the lack of type safety - constants and inline functions should be used instead. However, there are situations when using define is much simpler.
Okay, thanks zen. Indeed I was explaining it from the 'C' perspective. I'll keep this in mind as I continue to study C++.
I compile code with:
Visual Studio.NET beta2
And beware. Definining something like this might happen:
#define func1(x) Afunction(x *x); <--Notice the semi-colen
when used like this:
func1(3);
Expands to:
Afunction(3 *3) ; ; <--- Notice double insertion of semi-colen
I know this may sound stupid, but all the same, like array indexing accidents, sometimes this happens...
Code:#include <cmath> #include <complex> bool euler_flip(bool value) { return std::pow ( std::complex<float>(std::exp(1.0)), std::complex<float>(0, 1) * std::complex<float>(std::atan(1.0) *(1 << (value + 2))) ).real() < 0; }
Much worse, of course, is the related semicolon problem for #define constant values.
is interpreted by the compiler asCode:#define PI 3.141593; /*...*/ cos (radval * PI * 2);
And of course, the result is a compiler error. But at least that's easy enough to catch.Code:cos (radval * 3.141593; * 2);
So, (almost) never use semicolons with #define. (I've made that mistake way too many times.)
> #define SQURE(x) x*x
The compiler will not diagnose the problems caused by doing something like
y = SQURE( x + 1 );
Which would expand into
y = x + 1 * x + 1;
which is almost certainly not what you meant, but it's perfectly valid code.
And the utter chaos of trying
y = SQURE( x++ );
C++ inline functions are much better - you don't have all those surprises which will bite you if you use a macro in some unexpected way.
If you dance barefoot on the broken glass of undefined behaviour, you've got to expect the occasional cut.
If at first you don't succeed, try writing your phone number on the exam paper.
