Computer Programming

Math and Arithmetic

Java Programming

C Programming

How To

# How to write a programme in c to calculate that reads floating point number but displays only integer?

###### Wiki User

###### 2007-08-20 15:50:19

We can use any method. As we can find out the area of the circle

by three methods as i known.

1.ordinary programming

e.g. void main() {

int r;float area;

printf("\n\tEnter radius of the circle : "); scanf("%d",&r);

area=3.14*r*r; printf("Radius = %d and area=%f",r,area); } 2. By

using macros e.g. #define PI 3.14

#define AREA(x) PI*x*x 3. We can solve by user defined functions

also

## Related Questions

###### Asked in Math and Arithmetic, School Subjects, Definitions

### Is an integer a whole number?

yes However, integer is a representation of a whole number that
does not use fractions or decimals. A floating point number may
represent a whole number, but not be an integer. So 23 is a whole
number, 23 is an integer, but 23.00 is a floating point number, not
an integer.
All integers are whole numbers

###### Asked in Computer Programming

### What are advantages and disadvantages of Integer programming?

The advantages of integer arithmetic over floating point
arithmetic is the absence of rounding errors. Rounding errors are
an intrinsic aspect of floating point arithmetic, with the result
that two or more floating point values cannot be compared for
equality or inequality (or with other relational operators), as the
exact same original value may be presented slightly differently by
two or more floating point variables. Integer arithmetic does not
show this symptom, and allows for simple and reliable comparison of
numbers.
However, the disadvantage of integer arithmetic is the limited
value range. While scaled arithmetic (also known as fixed point
arithmetic) allows for integer-based computation with a finite
number of decimals, the total value range of a floating point
variable is much larger.
For example, a signed 32-bit integer variable can take values in
the range -231..+231-1 (-2147483648..+2147483647), an IEEE 754
single precision floating point variable covers a value range of
+/- 3.4028234 * 1038 in the same 32 bits.

###### Asked in C++ Programming

### Why do you need to use default arguments in a function?

You don't need to use default arguments in a function -- they
are optional. You use them if and when they are required.
Typically you will use them to gain the benefit of function
overloading without the need to provide completely separate
implementations.
As an example, consider the following trivial class
declaration:
struct foo
{
foo(): m_integer(0), m_floating(0.0) {}
foo(int integer, float floating): m_integer(integer),
m_floating(floating) {}
private:
int m_integer;
float m_floating;
};
Note that there are two constructors, a default constructor that
accepts no arguments and an overloaded constructor that accepts two
arguments. In both cases the implementations are fundamentally the
same (they both initialise the data members) so they could just as
easily be combined into a single constructor with default
arguments:
struct foo
{
foo(int integer=0, float floating=0.0): m_integer(integer),
m_floating(floating) {}
private:
int m_integer;
float m_floating;
};
Now you gain the benefit of construction overloading via a
single constructor. In effect you've actually created 4 different
construction methods, depending on which, if any, arguments you
supply:
foo a; // assigns 0 to integer and 0.0 to floating
foo b(1); // assigns 1 to integer and 0.0 to floating
foo c(1,1.0); // assigns 1 to integer and 1.1 to floating
foo d(,1.0); // assigns 0 to integer and 1.0 to floating

###### Asked in C++ Programming

### Give the details of built in datatypes provided by c plus plus?

char: A one-byte integer with implementation-defined
signedness.
signed char: A signed one-byte integer.
unsigned char: An unsigned one-byte integer.
wchar_t: A wide character of implementation-defined size and
signedness.
short: A signed integer with at least 16 bits.
unsigned short: An unsigned integer with at least 16 bits.
int: A signed integer with at least 16 bits.
unsigned int: An unsigned integer with at least 16 bits.
long: A signed integer with at least 32 bits.
unsigned long: An unsigned integer with at least 32 bits.
long long: A signed integer with at least 64 bits.
unsigned long long: An unsigned integer with at least 64
bits.
float: A floating-point number with 32 bits of precision.
double: A floating-point number with 64 bits of precision.
long double: A floating-point number with 80-96 bits of
precision.

###### Asked in Percentages, Fractions, and Decimal Values

### How do you convert 5 into a fraction?

5 is an integer and not a fraction. However, it can be expressed
in rational form as 5/1. You can then calculate equivalent rational
fractions if you multiply both, its numerator and denominator, by
any non-zero integer.
5 is an integer and not a fraction. However, it can be expressed in
rational form as 5/1. You can then calculate equivalent rational
fractions if you multiply both, its numerator and denominator, by
any non-zero integer.

###### Asked in Software and Applications (non-game), Computer Programming, C Programming

### In pointers to store float address is we can use integer variable?

You can't address memory with floating point values. All
pointers are integer values pointing to a location in memory,
regardless of what type it is pointing to. If you wanted a floating
point pointer, then the following should do the trick:
float *floatingPointer;
Note: If you wanted to ask that which integer type is big enough
to hold a (flat) pointer, then the answer: ptrdiff_t, intptr_t
(both signed) and size_t, uintptr_t (both unsigned).