Data in languages C

so that would be a number 2⁶³+2⁶² +...+2⁰ =18446744073709551615

Example:

// Include EEPROM library to store persistent data#include <EEPROM.h>

constintSERIAL_ADDR = 0;           // EEPROM address for the serial numberuint32_tdeviceSerial = 0;

voidsetup() {
  Serial.begin(9600);

  // Read four bytes from EEPROM into the 32-bit serialdeviceSerial = 0;
  for (inti = 0; i < 4; i++) {
    deviceSerial |= (uint32_t(EEPROM.read(SERIAL_ADDR + i)) << (8 * i));
  }

  // Print the retrieved serial numberSerial.print("Device Serial: ");
  Serial.println(deviceSerial);

  // Example: increment and store a new serialdeviceSerial++;
  for (inti = 0; i < 4; i++) {
    EEPROM.write(SERIAL_ADDR + i, (deviceSerial >> (8 * i)) & 0xFF);
  }
}

voidloop() {
  // Application code here...
}

// Modern style using boolboolflag=true;if(flag){// executes when flag == true}// Legacy style using intintvalue=1;if(value!=0){// executes when value is non-zero}

// Modern fixed-width integer types (C99/C11)#include<stdint.h>int8_tsmallNumber;   // exactly 8 bitsuint32_tlargeNumber;  // exactly 32 bits// Boolean type (C99 and later)#include<stdbool.h>boolflag;      // true or false_BoolrawFlag;   // underlying type// Structure exampletypedefstruct {
    intid;
    floatvalue;
} Example;

// Union exampleunionData {
    inti;
    floatf;
};

// Enumeration example with auto-incrementenumColor {
    RED,       // 0GREEN,     // 1BLUE = 5, // explicitly set to 5YELLOW// 6 (auto-incremented)
};
  

// Define a 2D pointstructPoint {
    intx;
    inty;
};

// Create and initialize an array of pointsPointpolygon[3] = {
    {0, 0},
    {10, 0},
    {5,  5}
};

// Accessing elementsfor (inti = 0; i < 3; i++) {
    printf("Point %d: (%d, %d)\n", i, polygon[i].x, polygon[i].y);
}
    

#pragma pack(push, 1)  // align members on 1-byte boundariesstructPackedPoint {
    charlabel;  // 1 byteintx;      // 4 bytesinty;      // 4 bytes
};
#pragma pack(pop)

// Interpret a 32-bit float as an integer bit-patternunionFloatInt {
    floatf;
    uint32_tu;
};

FloatIntvalue;
value.f = 3.14f;
printf("As int bits: 0x%08X\n", value.u);
    

a

b

0	0	0	0	0	0	0	0	0	0	0	0	0	1	1	1	0

a

0	0	0	0	0	0	0	0	0	0	0	0	1	1	0	0	0

b

If we now introduce another integer variable c:And we define the expression for summing the numbers a and b:memory status would be:The number that is calculated is stored in memory and to display it requires some command that prints the value to the standard output (console).
This is a printf function from the stdio.h header in c (see read and write data below) or in c ++, the cout function from the iostream header can be used.
In the previous example, the programmer commanded a = 14; and b = 22; programmatically determined the values of a and b and the program user would not be able to influence them. In most cases, it is necessary to ensure that the user enters the values as they wish, and to do so, a command is provided that the number typed on the keyboard is temporarily memorized by the user as a string of characters and then converted with the appropriate input binary conversion. See data reading below.

Constant data

If the value does not change during the program, then such data is defined as the constant addition of the official word const. For example. the basis of the natural logarithm would be defined as follows:We see that there is also an assigned value here. This is mandatory when declaring, as this value will not continue to change during the program.

Constants

​These are values for example 2, 25, 3.14, 7f, 9.81f,… ..
They are not reserved memory, but are simply used in expressions. However, constants also have their own data type. For example, 2 is an integer constant of type int, 2. or 2.0 are of type double, while 2f would be of float type.

Symbolic constants​

These are constants given by the identifier. For example. instead of writing 3.14 in the expressions for pi, we can use the #define directive to define the symbolic constant PI as follows:Then we could use this constant somewhere in expressions, e.g. for circle surface:​For the compiler, this will still be the value defined by #define among the directives, but for developers, it is given an identifier, thus better suggesting the purpose of its use.

Header files

In order to use features from other files in a particular file, such a file must be included using the #include <file> directive.
We call these files header files. In C, they have the extension .h. For example. to be able to use the printf and scanf functions to write and read data to standard output, ie. input we need to include the stdio.h file:
#include <stdio.h>
Either you need to include the math.h file in c, or the cmath file in c ++ to use the math functions.
#include <math.h>

A useful site for viewing header files in c and c ++ is:http://www.cplusplus.com/reference/

Reading and writing data in C

​They are entered as a string of characters. Since the memory data is stored in binary form, the data conversion must be performed.
The stdio.h file must be included among the preprocessor directives
#define<stdio.h>
Celestial input conversion
scanf(format, &podatak,&podatak,....,&podatak)
The format is text data. Individual conversions are expressed in sub-formats:
% nq, where q is the conversion code, and n is a supplementary conversion parameter.
Input Conversions: i, d,u, o, x,.
for short:              hi,hd....
forlong:                li, ld,...
Celestial output conversions: i, d,u, o, x,.
for short:              hi,hd....
forlong:                li, ld,...
Input Real-Number Conversions:
for float:               f,e,g.
fordouble:           lf, le,lg
for long double:                 Lf, Le,Lg                
Output Real-Number Conversions:
for float:               f,e,g.
fordouble:           f, e,g

Output conversion​
In the previous example of summation, it remains to show how data from memory is displayed on the screen.
The stdio.h file provides a printf whose syntax is:

 printf(format,var1,var2,..);

In our example, this would be:​
 printf(“%d”,c);

After executing this command, the console would display: Only result 36 is displayed.
If we would like to combine the output of the text and the number in the output, e.g. if we write "The sum of numbers 14 and 22 is 36", then the format parameter would actually be text with output formats for the output conversion for in this case integers "% d" or "% i". The parameters in the printf function, given after the format, are actually variables whose conversion is done, written in the order from left to right:After starting at the exit it would be: To allow the user to enter the desired values for a and b, we will use the scanf function from the stdio.h header.

Values for assigning values to variables a and b.

​a=14;
b=22;

should be replaced by:

​where% d is written twice the format for input conversion for integers, a & a and & b addresses of memory locations for data a and b.
The "&" operator provides the memory address of the data and is used for input and not for output conversion.

Before the scanf command, a printf command must be added to print a message, which tells the user what information to enter.

A complete task code would be: Examples:

• Enter the radius of the circle and calculate the area
• Load trapeze pages and calculate area.
• Load time in seconds and print as hh: mm: ss

---

Tasks Solutions 

​​Example 1-solution In the third step, we calculate the area using the known circle surface pattern. Multiplication requires the use of the "*" operator, while the symbolic constant is defined by the #define preprocessor directive at the top of the file.

In step 4, a message with the surface value, which is read from the memory marked in this program with P., is displayed. The %f format for double data is used for the output conversion.

Example 3-solution

​The problem is solved in 4 steps:
Here the user enters the time in seconds which should be an integer​To get minutes and hours from this number, we will use the operator % which gives the remainder of the division of two integers, as well as the operator "/" which gives the result of the division without the decimal part, that is, the whole number rounded to the first lower value. To get the number of whole hours in the total number of seconds we divide
time in seconds and 3600, timeSek/ 3600, and to get how many seconds left, we use "%", ie timeSek% 3600.
Code that does this:​If the time was 7400s, h would be 2 hours, because 7500/2 = 2, if we round to the first smaller integer, while remaining unallocated 300s. This is the result of a wash of 7200% 3600 = 300;
Similarly they would get minutes from the remaining seconds (restSek), but in this case they would take 60 for the divider because 1min = 60 sec;The rest would now remain seconds that needed no further sharing. Finally, to display the time, we use printf formatted to display 2 digits for hours, minutes and time. In the case of single-digit numbers, it displays 0 as a prefix. So:Complete code for this example: After running: The format % 02d, means the following,% is the start of inserting a variable value into the text, 2 is the number of digits to display, so if the number is a single digit it will be filled with a digit before 2, which in this example is "zero". "d" is the format label for decimal numbers.

---

---

Related articles

Data example in C/C++
​C Strings
Java programming
Algoritams-prime numbers
​Algoritams-arrays of Fibonacci
​
​
​
​