ü Why
Should Learn ‘C’ Language?
ü Inroduction
of ‘C’
ü Keywords
of ‘C’
ü Data
Type of ‘C’
ü Variables
in ‘C’
Why Should Learn ‘C’?
Learning the C programming language can be beneficial for a
variety of reasons.
1. Strong Foundation:
C is often considered the "Mother of all Programming Languages".
The following programming languages, including C++, C#, and
Java, built upon C.
2. Systems Programming: C is commonly used for systems
programming tasks, such as writing operating systems, device drivers, and
low-level software.
3. Learning C helps you understand how computers work at a
fundamental level, as you have direct control over memory, pointers, and the
CPU. This knowledge can be valuable for debugging and optimizing code in other
languages.
4. Educational Value: C is often taught in computer science
and programming courses.
Higher-level languages like Python, Java, and JavaScript are
more suitable for certain applications due to their
***
C Language:
C Language:
C for the
beginner 's by Md Farrukh Asif
Operators
in C by Md. Farrukh Asif
C's
Control Flow by Md. Farrukh Asif
String handling in C by Md Farrukh Asif
The
Function of C Language by Md. Farrukh Asif
File Handling
with various statements/syntaxes in Programming and their output in C Language.
C
for beginner's programming with output. Course Code – 106 [‘C’]) TMBU,BGP
BCA
SOLVED EXAMINATION QUESTIONS WITH ANSWERS Course Code – 106 [‘C’]) TMBU,BGP
C is a widely used, general-purpose programming language
that was developed in the early 1970s by Dennis Ritchie at Bell Labs.
Here's a brief
introduction to C and its development:
1. Origins and Development:
C was created as an evolution of the B programming language
and was developed at Bell Labs by Dennis Ritchie between 1969 and 1973.
2. Characteristics:
C is a procedural, imperative programming language. It
emphasizes structured programming techniques, which are essential for building
clear and maintainable software.
It provides low-level memory manipulation features and
access to hardware, making it suitable for system-level programming.
C is known for its efficiency and portability, as it can be
easily adapted to various computer architectures.
3. Standardization:
The first standardized version of C, known as ANSI C, was
published in 1989. It was later adopted as an international standard (ISO/IEC
9899).
Subsequent revisions and improvements have been made, with
the most recent standard being C18, which was adopted in 2018.
4. Influence and importance:
C has had a profound influence on the development of
programming languages. Many modern languages, including C++, Visual C++, C#, and Java, have borrowed syntax and
concepts from C.
It introduced the idea of a standard library, which includes
functions for common operations like I/O and string manipulation.
5. Popularity and Usage:
It is a popular choice for developing operating systems,
device drivers, and high-performance applications.
6. Legacy:
C's simplicity and power have ensured its longevity. Even in
the era of more advanced programming languages.
It remains a foundational language in computer science and
is often taught as an essential part of a programmer's education.
Don't know how to learn C Programming, the right way? Enroll
in our Interactive C Course for FREE.(farrukhasif16@gmail.com) or Whatsapp : 8800304018
ü Keywords & Identifier (Total 32)
|
auto |
double |
int |
struct |
|
case |
else |
long |
switch |
|
break |
enum |
register |
void |
|
char |
extern |
Static |
union |
|
const |
Float |
short |
unsigned |
|
continue |
goto |
signed |
typedef |
|
default |
for |
sizeof |
volatile |
|
do |
if |
return |
while |
Rules for Identifiers
in C:
·
An identifier is a sequence of letters, digits,
and underscores (_) that must begin with a letter or an underscore.
·
Identifiers are case-sensitive, meaning
"myVariable" and "myvariable" are considered different
identifiers.
·
They can be of any length, but it's a good
practice to keep them meaningful and not excessively long.
·
You should avoid using C keywords as identifiers
because they have predefined meanings in the language.
·
Special characters (e.g., !, @, $) are not
allowed in identifiers.
Here are some examples of valid C identifiers:
·
myVariable
·
counter
·
MAX_SIZE
·
_data
·
sum_total
And here are some examples of invalid C identifiers:
·
123abc (starts with a digit)
·
my-variable (contains a hyphen)
It's important to choose meaningful and descriptive
identifiers to make your code more readable and maintainable. Additionally, be
aware of naming conventions (e.g., camelCase, snake_case) and coding standards
used in your project or organization.
ü
Variables & Constants
Variables and constants are fundamental elements in
programming, including in the C programming language. They are used to store
and manage data within a program. Here's an overview of variables and constants
in C:
Variables:
Declaration: Before you can use a variable, you must declare
it. A variable declaration specifies its data type and optionally an initial
value.
int myVariable; // Declaration of an integer variable
float pi = 3.14159; // Declaration and initialization of a float variable
Assignment: You can assign values to variables using the
assignment operator =.
myVariable = 42; // Assigning the value 42 to myVariable
Data Types: C supports various data types for variables,
including int, float, double, char, void and more. Each data type has a
specific size and range.
Scope: Variables can have different scopes, such as local
variables (defined within a function) and global variables (defined outside of
any function). Scope determines where the variable is accessible.
Constants:
Constants: Constants are values that do not change during
the execution of a program. In C, you can define constants using the const
keyword.
const int max_value = 100; // Declaration of an integer constant
Enumeration Constants: You can define a list of related
integer constants using enumerations (enum).
enum Color { RED, GREEN, BLUE }; // Declaration of an
enumeration
Preprocessor Constants: You can also define constants using
preprocessor directives (#define). These are replaced by the preprocessor
before compilation.
#define PI 3.14159
Read-Only: Constants are read-only and cannot be changed
once they are defined. They are used when you have values that should not be
modified during the program's execution.
Benefits: Constants make code more readable, provide a
central place to manage important values, and help prevent accidental
modification of critical data.
ü C Data Types
In the C programming language, data types are used to define
the type of data that a variable can hold. C supports several fundamental data
types, and these can be categorized into the following main groups:
Basic Data Types:
int: Used to store integers (whole numbers).
char: Used to store single characters.
float: Used to store single-precision floating-point
numbers.
double: Used to store double-precision floating-point
numbers.
void: Used to indicate that a function does not return any
value.
Derived Data Types:
array: A collection of elements of the same data type.
pointer: A variable that stores the memory address of
another variable.
structure: A user-defined composite data type that groups
different variables together.
union: Similar to a structure, but it can only hold one
value at a time.
enum: A user-defined data type that consists of a set of
named integer constants.
Enumeration Data Type:
enum: Defines a set of named integer constants, typically
used to create user-friendly names for integer values.
Typedef Data Type:
typedef: Used to create a new name for an existing data
type. It is often used to improve code readability and maintainability.
C also provides modifiers that can be used with the basic
data types to specify the storage size and sign of variables. For example:
short int: A short integer with reduced storage size.
long int: A long integer with extended storage size.
signed: Used to specify a variable as signed (positive and
negative values).
unsigned: Used to specify a variable as unsigned (only
positive values).
Here are some examples of variable declarations using
different data types:
These data types are used to declare variables, function
parameters, and return types in C programs, allowing the programmer to work
with various types of data efficiently.
*** See You Again ***
************************
Share and Subscribe with Like
Nice coverage
ReplyDelete