# Increment decrement problem in c

```Hello guys let's we have an syntax and related values let's see how this works. Evaluate the given syntax
z = ++x + y-- - ++y - x-- - x-- - ++y - x--
where x = 7 y = -3```
```z = ((((((++x + y--) - ++y) - x--) - x--) - ++y) - x--)
so first(++x + y--) will be evaluated
(++x + y--)
8 + (-3)        x=8 y = -4
z = (((((5 - ++y) - x--) - x--) - ++y) - x--)
(5 - ++y)
5 - ( -3)  x=8 y = -3

z = ((((8 - x--) - x--) - ++y) - x--)
(8 - x--)
8 - 8      x =7 y = -3
z = (((0- x--) - ++y) - x--)
(0- x--)
0 - 7      x =6 y = -3
z = (((-7 - ++y) - x--)
(-7 - ++y)
-7 - (-2)  x = 6 y = -2
z = (-5 - x--)
-5 -6       x =5 y -2
z = -11```

# Understanding “extern” keyword in C

## Hello , one more important stuff to understand

I’m sure that this post will be as interesting and informative to C virgins (i.e. beginners) as it will be to those who are well versed in C. So let me start with saying that extern keyword applies to C variables (data objects) and C functions. Basically extern keyword extends the visibility of the C variables and C functions. Probably that’s is the reason why it was named as extern.

Though (almost) everyone knows the meaning of declaration and definition of a variable/function yet for the sake of completeness of this post, I would like to clarify them. Declaration of a variable/function simply declares that the variable/function exists somewhere in the program but the memory is not allocated for them. But the declaration of a variable/function serves an important role. And that is the type of the variable/function. Therefore, when a variable is declared, the program knows the data type of that variable. In case of function declaration, the program knows what are the arguments to that functions, their data types, the order of arguments and the return type of the function. So that’s all about declaration. Coming to the definition, when we define a variable/function, apart from the role of declaration, it also allocates memory for that variable/function. Therefore, we can think of definition as a super set of declaration. (or declaration as a subset of definition). From this explanation, it should be obvious that a variable/function can be declared any number of times but it can be defined only once. (Remember the basic principle that you can’t have two locations of the same variable/function). So that’s all about declaration and definition.
Now coming back to our main objective: Understanding “extern” keyword in C. I’ve explained the role of declaration/definition because it’s mandatory to understand them to understand the “extern” keyword. Let us first take the easy case. Use of extern with C functions. By default, the declaration and definition of a C function have “extern” prepended with them. It means even though we don’t use extern with the declaration/definition of C functions, it is present there. For example, when we write.

`    int foo(int arg1, char arg2);`

There’s an extern present in the beginning which is hidden and the compiler treats it as below.

`    extern int foo(int arg1, char arg2);`

Same is the case with the definition of a C function (Definition of a C function means writing the body of the function). Therefore whenever we define a C function, an extern is present there in the beginning of the function definition. Since the declaration can be done any number of times and definition can be done only once, we can notice that declaration of a function can be added in several C/H files or in a single C/H file several times. But we notice the actual definition of the function only once (i.e. in one file only). And as the extern extends the visibility to the whole program, the functions can be used (called) anywhere in any of the files of the whole program provided the declaration of the function is known. (By knowing the declaration of the function, C compiler knows that the definition of the function exists and it goes ahead to compile the program). So that’s all about extern with C functions.
Now let us the take the second and final case i.e. use of extern with C variables. I feel that it more interesting and information than the previous case where extern is present by default with C functions. So let me ask the question, how would you declare a C variable without defining it? Many of you would see it trivial but it’s important question to understand extern with C variables. The answer goes as follows.

`    extern int var;`

Here, an integer type variable called var has been declared (remember no definition i.e. no memory allocation for var so far). And we can do this declaration as many times as needed. (remember that declaration can be done any number of times) So far so good. Now how would you define a variable. Now I agree that it is the most trivial question in programming and the answer is as follows.

`    int var;`

Here, an integer type variable called var has been declared as well as defined. (remember that definition is the super set of declaration). Here the memory for var is also allocated. Now here comes the surprise, when we declared/defined a C function, we saw that an extern was present by default. While defining a function, we can prepend it with extern without any issues. But it is not the case with C variables. If we put the presence of extern in variable as default then the memory for them will not be allocated ever, they will be declared only. Therefore, we put extern explicitly for C variables when we want to declare them without defining them. Also, as the extern extends the visibility to the whole program, by externing a variable we can use the variables anywhere in the program provided we know the declaration of them and the variable is defined somewhere.
Now let us try to understand extern with examples.
Example 1:

 `int` `var;` `int` `main(``void``)` `{` `   ``var = 10;` `   ``return` `0;` `}`

Analysis: This program is compiled successfully. Here var is defined (and declared implicitly) globally.
Example 2:

 `extern` `int` `var;` `int` `main(``void``)` `{` `  ``return` `0;` `}`

Analysis: This program is compiled successfully. Here var is declared only. Notice var is never used so no problems.
Example 3:

 `extern` `int` `var;` `int` `main(``void``)` `{` ` ``var = 10;` ` ``return` `0;` `}`

Analysis: This program throws error in compilation. Because var is declared but not defined anywhere. Essentially, the var isn’t allocated any memory. And the program is trying to change the value to 10 of a variable that doesn’t exist at all.
Example 4:

 `#include "somefile.h"` `extern` `int` `var;` `int` `main(``void``)` `{` ` ``var = 10;` ` ``return` `0;` `}`

Analysis: Supposing that somefile.h has the definition of var. This program will be compiled successfully.
Example 5:

 `extern` `int` `var = 0;` `int` `main(``void``)` `{` ` ``var = 10;` ` ``return` `0;` `}`

Analysis: Guess this program will work? Well, here comes another surprise from C standards. They say that..if a variable is only declared and an initializer is also provided with that declaration, then the memory for that variable will be allocated i.e. that variable will be considered as defined. Therefore, as per the C standard, this program will compile successfully and work.
So that was a preliminary look at “extern” keyword in C.
I’m sure that you want to have some take away from the reading of this post. And I would not disappoint you. In short, we can say
1. Declaration can be done any number of times but definition only once.
2. “extern” keyword is used to extend the visibility of variables/functions().
3. Since functions are visible through out the program by default. The use of extern is not needed in function declaration/definition. Its use is redundant.
4. When extern is used with a variable, it’s only declared not defined.
5. As an exception, when an extern variable is declared with initialization, it is taken as definition of the variable as well.

Copied from GeekforGeeks Thanx GeekforGeeks.

# Constant In C

A C constant is usually just the written version of a number. For example 1, 0, 5.73, 12.5e9. We can specify our constants in octal or hexadecimal, or force them to be treated as long integers.
• Octal constants are written with a leading zero – 015.
• Long constants are written with a trailing L – 890L.

Character constants are usually just the character enclosed in single quotes; ‘a’, ‘b’, ‘c’. Some characters can’t be represented in this way, so we use a 2 character sequence as follows.

 `'\n' newline'\t' tab'\\' backslash'\'' single quote'\0' null ( Usedautomatically to terminate character string )`
In addition, a required bit pattern can be specified using its octal equivalent.
‘\044’ produces bit pattern 00100100.
Character constants are rarely used, since string constants are more convenient. A string constant is surrounded by double quotes eg “Brian and Dennis”. The string is actually stored as an array of characters. The null character ‘\0’ is automatically placed at the end of such a string to act as a string terminator.
A character is a different type to a single character string. This is important poing to note.

# Defining Constants

ANSI C allows you to declare constants. When you declare a constant it is a bit like a variable declaration except the value cannot be changed.
The const keyword is to declare a constant, as shown below:
 `int const a = 1;const int a =2;`
Note:
• You can declare the const before or after the type. Choose one an stick to it.
• It is usual to initialise a const with a value as it cannot get a value any other way.
The preprocessor #define is another more flexible (see Preprocessor Chapters) method to define constants in a program.
 `#define TRUE 1#define FALSE 0#define NAME_SIZE 20`
Here TRUE, FALSE and NAME_SIZE are constant
You frequently see const declaration in function parameters. This says simply that the function is not going to change the value of the parameter.
The following function definition used concepts we have not met (see chapters on functions, strings, pointers, and standard libraries) but for completenes of this section it is is included here:
 `void strcpy(char *buffer, char const *string)`

# The enum Data type

enum is the abbreviation for ENUMERATE, and we can use this keyword to declare and initialize a sequence of integer constants. Here’s an example:
 `enum colors {RED, YELLOW, GREEN, BLUE};`
I’ve made the constant names uppercase, but you can name them which ever way you want.
Here, colors is the name given to the set of constants – the name is optional. Now, if you don’t assign a value to a constant, the default value for the first one in the list – RED in our case, has the value of 0. The rest of the undefined constants have a value 1 more than the one before, so in our case, YELLOW is 1GREEN is 2 and BLUE is 3.
But you can assign values if you wanted to:
 `enum colors {RED=1, YELLOW, GREEN=6, BLUE };`
Now RED=1, YELLOW=2, GREEN=6 and BLUE=7.
The main advantage of enum is that if you don’t initialize your constants, each one would have a unique value. The first would be zero and the rest would then count upwards.
You can name your constants in a weird order if you really wanted…
 `#include int main() { enum {RED=5, YELLOW, GREEN=4, BLUE}; printf("RED = %d\n", RED); printf("YELLOW = %d\n", YELLOW); printf("GREEN = %d\n", GREEN); printf("BLUE = %d\n", BLUE); return 0;}This will produce following results RED = 5 YELLOW = 6 GREEN = 4 BLUE = 5`

Copied From Tutorial C

# Difference between Near , Far and Huge Pointer

as we know by default the pointers are near for example int *p is a near pointer… size of near pointer is 2 bytes in case of 16 bit compiler…….. n we already know very well size varies compiler to compiler…… They only store the offset of the address the pointer is referencing. . An address consisting of only an offset has a range of 0 – 64K bytes…. i think there is no need to discuss near pointers anymore…. so come to the main point….. that is far and huge pointers……

far and huge pointers:
Far and huge pointers have a size of 4 bytes. They store both the segment and the offset of the address the pointer is referencing. thn what is the difference between them ………..

Limitation of far pointer:
We cannot change or modify the segment address of given far address by applying any arithmetic operation on it. That is by using arithmetic operator we cannot jump from one segment to other segment. If you will increment the far address beyond the maximum value of its offset address instead of incrementing segment address it will repeat its offset address in cyclic order. this is also called wrapping…..i.e. if offset is 0xffff and we add 1 then it is 0x0000 and similarly if we decrease 0x0000 by 1 then it is 0xffff and remember there is no change in the segment….

Now i am going to compare huge and far pointers……….

1.
When a far pointer is incremented or decremented ONLY the offset of the pointer is actually incremented or decremented but in case of huge pointer both segment and offset value will change…..
like if we have

int main()
{
char far* f=(char far*)0x0000ffff;
printf(“%Fp”,f+0x1);
return 0;
}

then the output is:
0000:0000

as we see there is no change in segment value…….

and in case of huge……..

int main()
{
char huge* h=(char huge*)0x0000000f;
printf(“%Fp”,h+0x1);
return 0;
}
then the o/p is:
0001:0000

it shows bcoz of increment operation not only offset value but segment value also change………. that means segment will not change in case of far pointers but in case of huge it can move from one segment to another ……
2.
When relational operators are used on far pointers only the offsets are compared.In other words relational operators will only work on far pointers if the segment values of the pointers being compared are the same. and in case of huge this will not happen, actually comparison of absolute addresses takes place…... lets understand with the help of an example…
in far………………………….

int main()
{
char far * p=(char far*)0x12340001;
char far* p1=(char far*)0x12300041;
if(p==p1)
printf(“same”);
else
printf(“different”);
return 0;
}

Output:
different
in huge…………………..

int main()
{
char huge * p=(char huge*)0x12340001;
char huge* p1=(char huge*)0x12300041;
if(p==p1)
printf(“same”);
else
printf(“different”);
return 0;
}

Output:
same

Explanation:
as we see the absolute address for both p and p1 is 12341 (1234*10+1 or 1230*10+41) but they are not considered equal in 1st case becoz in case of far pointers only offsets are compared i.e. it will check whether 0001==0041…. that we know is false…. and know see what will happen in case of huge…..the comparison operation is performed on absolute addresses that are equal as i already told……
3.
A far pointer is never noramlized but a huge pointer is normalized . A normalized pointer is one that has as much of the address as possible in the segment, meaning that the offset is never larger than 15.
suppose if we have 0x1234:1234 then the normalized form of it is 0x1357:0004(absolute address is 13574)…….
A huge pointer is normalized only when some arithmetic operation is performed on it … and not noramlized during assignment….
int main()
{
char huge* h=(char huge*)0x12341234;
char huge* h1=(char huge*)0x12341234;
printf(“h=%Fp\nh1=%Fp”,h,h1+0x1);
return 0;
}
Output:
h=1234:1234
h1=1357:0005
Explanation:
as i said above huge is not normalized in case of assignment……but if an arithmetic operation is performed on it ….. it will be normalized…. so h is 1234:1234 and h1 is 1357:0005……….that is normalized…….
4.
The offset of huge pointer is less than 16 because of normalization and not so in case of far pointers……………….
lets take an example to understand what i want to say…..
int main()
{
char far* f=(char far*)0x0000000f;
printf(“%Fp”,f+0x1);
return 0;
}
Output:
0000:0010
in case of huge
int main()
{
char huge* h=(char huge*)0x0000000f;
printf(“%Fp”,h+0x1);
return 0;
}

Output:
0001:0000
Explanation:
as we increment far pointer by 1 it will be 0000:0010…… and as we increment huge pointer by 1 thn it will be 0001:0000 bcoz its offset cant be greater than 15 in other words it will be normalized…………
Copied from C Stuff