 # how ampersand works in print function?

• Last Update :
• Techknowledgy :

Ranks are the position from right to left in a binary representation of a number.

```0010
^
^ ^ ^
||
||
||
| + --rank 0 ||
+ -- - rank 1 |
+ -- --rank 2 +
-- -- - rank 3```

`2 & 3` can be translated, in binary as `0010 & 0011` :

```  0010
&
0011
-- -- --
0010```

`7 & 8` can be translated, in binary as `0111 & 1000` :

```  0111
&
1000
-- -- --
0000```

Suggestion : 2

& is a bitwise and operator : each anycodings_python-3.x bit of the same rank are and evaluated, anycodings_python-3.x if both bits are 1, the result of that anycodings_python-3.x rank is 1,Please some one help to understand how & anycodings_python-3.x is working in python.,print(2&3) printed 2. But want to anycodings_python-3.x understand how is it working?,Ranks are the position from right to anycodings_python-3.x left in a binary representation of a anycodings_python-3.x number.

print(2&3) printed 2. But want to anycodings_python-3.x understand how is it working?

`print(2 & 3)`

Output: 2

`print(7 & 8)`

Output: 0

```print("a" & "b")

Exception: TypeError: unsupported operand type(s) for &: 'str'
and 'str'```

Ranks are the position from right to anycodings_python-3.x left in a binary representation of a anycodings_python-3.x number.

```0010
^
^ ^ ^
||
||
||
| + --rank 0 ||
+ -- - rank 1 |
+ -- --rank 2 +
-- -- - rank 3```

2 & 3 can be translated, in binary anycodings_python-3.x as 0010 & 0011 :

```  0010
&
0011
-- -- --
0010```

7 & 8 can be translated, in binary anycodings_python-3.x as 0111 & 1000 :

```  0111
&
1000
-- -- --
0000```

Suggestion : 3

Last Updated : 22 May, 2020

Output:

`2`

Suggestion : 4

The ampersand used in the function prototype. function ( & parameter_name ) To make a normal parameter into a pass by reference parameter, we use the "& param" notation. The ampersand (&) is the syntax to tell C that any changes made to the parameter also modify the original variable containing the data. , To make a normal parameter into a pass by reference parameter, we use the "& param" notation. The ampersand (&) is the syntax to tell C that any changes made to the parameter also modify the original variable containing the data. , One reason to use reference parameters is to make the program more "efficient". Consider passing in a structure as a parameter. If the structure is very big, and we copy all of it, then we are using a lot of unnecessary memory. , A reference parameter "refers" to the original data in the calling function. Thus any changes made to the parameter are ALSO MADE TO THE ORIGINAL variable.

Here is the syntax for the function declaration or Prototype:

```        RETURN_TYPE name_of_function(PARAMETER_TYPE name_of_param, PARAMETER_TYPE name_of_param, etc);

// here are some examples of prototypes used at the top of a file:
float sqrt(float x);

In C, the "main" function is treated the same as every function, it has a return type (and in some cases accepts inputs via parameters). The only difference is that the main function is "called" by the operating system when the user runs the program. Thus the main function is always the first code executed when a program starts.

```        int // the main function will usually returns a 0 if successful
main() // this is the name, in this case: main
{
// this is the body of the function (lots of code can go here)
}```

## Examples of C Functions:

```        double // this is the return type
max(double param1, double param2) // this is the name, followed by the parameters
{
if (param1 > param2) {
return param1; // Notice: that param1 is of type double and the return
//         type is also of type double
} else {
return param2;
}
}

void // This is the return type (void means no value is computed and returned by the function!)
print_happy_birthday(int age) {
printf("Congratulations on your %d th Birthday\n", age);
return; // you can "terminate" a void function by using return.
// HERE it is REDUNDANT because the function is over anyway.
}```

In C, the default is to pass by value. For example:

```        //
// C function using pass by value. (Notice no &)
//
void
doit(int x) {
x = 5;
}

//
// Test function for passing by value (i.e., making a copy)
//
int
main() {
int z = 27;
doit(z);
printf("z is now %d\n", z);

return 0;
}```

I suggest that you use a C++ compiler such as g++ which allows the following pass by reference syntax (a much more modern style). The Syntax is to use the '&' in front of the parameter name in the function declaration. The calling code and usage inside the function are the same as before. For example:

```        //
// C++ using Reference Parameter!
//
void
doit(int & x) {
x = 5;
}

//
// Test code for passing by a variable by reference
//
int
main() {
int z = 27;
doit(z);
printf("z is now %d\n", z);

return 0;
}```