What are Programming Languages?Types of softwaresC IntroductionC HistoryC FeaturesC ApplicationsCharacter set, ASCII TableC Programming Language Standard
Turbo C++ editor installationExploring the Turbo C++ EnvironmentC Hellow world programHow a C Program ExecuteCompilation process in C
C #include statementC Displaying OutputC Reading input from the terminalC Data typesC VariablesC Variable Naming ConventionsC ConstantsC Identifiers & Naming RulesC LiteralsC CommentsC KeywordsC Type QualifiersC TokensC Format SpecifiersC Escape SequencesC preprocessorASCII value in CStatic in CWhat are Compiler ErrorsWhat are Compiler WarningsWhat are Linker ErrorsWhat are Runtime ErrorsWhat are Logical ErrorsCompile time vs RuntimeC program to displays your name  C - Basics Practice Test.1  C - Basics Practice Test.2  C - Basics Practice Test.3  C - Basics Practice Test.4  C - Basics Practice Test.5
C Arithmetic OperatorsC Assignment OperatorsC Relational OperatorsC Logical OperatorsC Increment & Decrement OperatorsC Conditional or Ternary OperatorC Bitwise OperatorsC Type CastingC Sizeof OperatorC Comma OperatorC Operators Precedence and AssociativityC ExpressionsC Evaluation of Expressions  C - Operators Practice Test.1  C - Operators Practice Test.2  C - Operators Practice Test.3
Input-Output Library FunctionsNon-Formatted Input and OutputCharacter Oriented Library FunctionsFormatted Library FunctionsMathematical Library Functions  C - Input-Output Functions Practice Test.1
C ifC if-elseC nested if-elseC if-else-ifC switch-caseC if vs switch-caseC LoopsC while loopC do-while loopC while vs do-whileC for loopC for vs WhileC Nested LoopsC Jump Control structuresC break statementC continue statementC goto statementC continue vs goto statementC return statementC goto vs return statement  C - Control Statements Practice Test.1  C - Control Statements Practice Test.2  C - Control Statements Practice Test.3
C FunctionsC Advantages of Using FunctionsC Function PrototypeC Basic Function DesignsC Programs Using FunctionsC ScopeC Local Variable and Global VariableWhy int main() return 03 Place to declare functionsC RecursionC Base Condition in RecursionC Iteration vs RecursionC Stack Overflow Error in RecursionC Nested functionsC Variable Length Number of ArgumentsC Parameter Passing – Call by value and Call by RefC Passing Strings to FunctionsImplementation of square() functionImplementation of factorial() functionImplementation of pow(x, n) functionImplementation of reverse(int) functionImplementation of countDigits(int) functionImplementation of palindrome(int) functionImplementation of primeNumber(int) function  C - Functions Practice Test.1  C - Functions Practice Test.2
What is Array?One dimensional ArrayAccessing element of 1D arrayReading and displaying elementsPrograms on 1D ArraysTwo Dimensional ArrayAccessing Element of 2D ArrayReading and Displaying ElementsPrograms on 2D ArraysPassing 1D arrays to FunctionsPassing 2D arrays to FunctionsThree Dimensional Array  C - Array Practice Test.1  C - Array Practice Test.2
Strings in CStoring StringsC The String DelimiterC String Literals (String Constants)C Strings vs. CharactersC Declaring and Initialization of StringsC Strings and the Assignment OperatorC String Input Functions / Reading StringsC String Output Functions / Writing StringsC fscanf() and fprintf() FunctionsC Single Character Library FunctionsC String Manipulation Library FunctionsC Programs Using Character ArraysC Array of StringsC Programs Using Array of Strings  C - Strings Practice Test.1  C - Strings Practice Test.2
Pointers in CUnderstanding Memory AddressesDeclare and Initialize Pointer VariablePointer Operators in Csizeof() Operator in CPointer Advantages and DisadvantagesDereferencing/Redirecting Pointer VariablesPointer Declaration versus RedirectionConst Pointer in CVoid Pointer in CNull Pointer in CC Pointer CompatibilityArray of PointersPointer to PointerPointer ArithmeticC Functions Returning PointersC Pointer to FunctionPointers and One-Dimensional ArrayPointers and Two-Dimensional ArrayPointers and StringsDynamic Memory Allocation Functions  C - Pointers Practice Test.1  C - Pointers Practice Test.2  C - Pointers Practice Test.3
Previous
Next

C Format Specifiers

In C, format specifiers are special placeholders used in formatted input and output functions to specify the data type of the values being read or written. They determine how data is formatted when displayed on the screen or when read from the input. Format specifiers are primarily used with functions like printf, scanf, and other related I/O functions from the C Standard Library.

Here are some commonly used format specifiers in C:

1. Integer Format Specifiers:
  • %d: Used for reading and printing int values.
  • %u: Used for reading and printing unsigned int values.
  • %ld: Used for reading and printing long int values.
  • %lu: Used for reading and printing unsigned long int values.
  • %lld: Used for reading and printing long long int values.
  • %llu: Used for reading and printing unsigned long long int values.
  • %x or %X: Used for reading and printing hexadecimal values (integers in base 16).

Here are some examples of integer format specifiers:

%d: This specifier is used for integers, which are whole numbers. For example, if you have an integer variable like int age = 25;, you can print it using %d. 


int age = 25;
printf("My age is: %d\n", age);

Output: My age is: 25

%x or %X: These specifiers are used for hexadecimal numbers, which are often used in computer memory and low-level programming. They represent numbers in base 16 (using digits 0-9 and A-F for 10-15). 


int hexValue = 0x1A; // Hexadecimal value
printf("Hexadecimal value: %X\n", hexValue);

Output: Hexadecimal value: 1A

2. Floating-Point Format Specifiers:
  • %f: Used for reading and printing float and double values in decimal notation.
  • %lf: Used for reading and printing double values.
  • %e or %E: Used for scientific notation (exponential format) for float and double values.
  • %g or %G: Used to print floating-point values in either %f or %e notation, depending on the value.

Here are some examples of Floating-Point format specifiers:

%f: This specifier is used for floating-point numbers, which include decimal fractions. If you have a floating-point number like double price = 9.99;, you can print it using %f. 


double price = 9.99;
printf("Price: %f\n", price);

Output: Price: 9.990000

%e or %E: These specifiers are used for scientific notation, which is a way to represent very large or very small numbers. For example: 


double scientificNotation = 2.0e-3; // Scientific notation (0.002)
printf("Value in scientific notation: %e\n", scientificNotation);

Output: Value in scientific notation: 2.000000e-03

3. Character and String Format Specifiers:
  • %c: Used for reading and printing a single character.
  • %s: Used for reading and printing strings (arrays of characters).
  • %p: Used for reading and printing pointers (memory addresses).

Here are some of the examples of Character and String format specifiers:

%c: This specifier is used for individual characters, like letters or symbols. 


char letter = 'A';
printf("First letter of the alphabet: %c\n", letter);

Output: First letter of the alphabet: A

%s: This specifier is used for strings, which are sequences of characters. 


char greeting[] = "Hello";
printf("Greeting: %s\n", greeting);

Output: Greeting: Hello

4. Width and Precision Specifiers:
  • %<width>d: Specifies a minimum width for the output, padding with spaces if necessary.
  • %<width>.<precision>f: Specifies the width and precision for floating-point numbers.

Here are some examples of how Width and Precision format specifiers are used in printf:

You can control the width (how many characters wide the output is) and precision (how many decimal places for floating-point numbers) using format specifiers like %6d or %.2f. Here's an example: 


double value = 3.14159265359;
printf("Value with width and precision: %10.2f\n", value);

Output: Value with width and precision: 3.14

In this example, %10.2f means the output should be at least 10 characters wide with 2 decimal places.

5. Modifiers:
  • l: Used as a modifier with integer format specifiers to indicate long or with floating-point specifiers to indicate double.
  • ll: Used as a modifier with integer format specifiers to indicate long long.
  • h: Used as a modifier with integer format specifiers to indicate short.

Let's provide an example of using the l modifier as part of format specifiers for integer and floating-point values in C:

%ld for long: When you want to work with long int values, you can use the %ld format specifier with the l modifier. long is used when you need to store larger integer values. 


long int bigNumber = 1234567890L;
printf("A big number: %ld\n", bigNumber);

Output: A big number: 1234567890

The l modifier is essential to indicate that you are working with a long int.

%lf for double: When you want to work with double values, you can use the %lf format specifier with the l modifier. double is used for real numbers with decimal places. 


double realValue = 3.14159265359;
printf("A real value: %lf\n", realValue);

Output: A real value: 3.141593

The l modifier is used here to specify that you are dealing with a double data type.

These examples demonstrate the use of the l modifier to indicate that you are working with long and double data types when using format specifiers.

6. Other Format Specifiers:
  • %o: Used for octal (base 8) representation.
  • %u: Used for unsigned integers.
  • %%: Used to print a literal percent sign (%).

Here are some examples of how format specifiers are used in printf: 


int num = 42;
printf("Integer: %d\n", num);

double pi = 3.14159265359;
printf("Double: %.2lf\n", pi); // Display two decimal places

char grade = 'A';
printf("Character: %c\n", grade);

char name[] = "John";
printf("String: %s\n", name);

void *ptr = NULL;
printf("Pointer: %p\n", ptr);

When using format specifiers, it's important to ensure that the data type of the variable being printed or read matches the format specifier to prevent undefined behavior and unexpected output.

These are the basics of format specifiers in C. They help you control how your data is displayed when using functions like printf. Understanding format specifiers is essential for formatting your program's output effectively.

Previous
Next