Day: August 10, 2010

Programming in C: Important Points on Data Types

Understanding int and short

The size of int in C can be either 16-bit or 32-bit, depending on the machine architecture and compiler implementation. Generally:

  • On older 16-bit systems, int is 16 bits.
  • On modern 32-bit and 64-bit systems, int is 32 bits.
  • short is often 16 bits, though it can vary based on the compiler.

Signed and Unsigned Characters

The signed and unsigned qualifiers can be applied to char. However, whether plain char (i.e., without signed or unsigned specified) is signed or unsigned is machine-dependent. This can affect operations involving negative values. For portability, it’s best to explicitly declare signed char or unsigned char when working with character data.

Implicit Type Conversions

When assigning between different data types, implicit conversions occur:

  • If x is float and i is int, the assignment x = i; converts i to float.
  • Conversely, i = x; truncates x to an integer, losing the decimal portion.

Understanding these implicit conversions is crucial to avoid unexpected results.

Specifying Types Correctly in Expressions

When writing expressions, you must ensure that constant arithmetic follows correct type rules. Consider the following example:

(float) a = (b - 18) * 7 / 9;

In this case, the constant division 7 / 9 is treated as integer division, which results in 0 (since both operands are integers). To ensure correct floating-point computation, use:

(float) a = (b - 18) * 7.0 / 9.0;

or explicitly cast part of the expression:

(float) a = (float)(b - 18) * 7 / 9;

This prevents unintended truncation and ensures proper floating-point arithmetic.

Integer Ranges Depend on Machine Architecture

The range of int and float types is machine-dependent. For example, on a system where int is 16 bits:

  • The total number of values is 2^16 = 65536.
  • Signed integers range from -32,768 to 32,767 (65536 / 2).

On a 32-bit system, the signed integer range extends to -2,147,483,648 to 2,147,483,647 (2^31).

Conditional Expressions and Type Conversion

Consider the following expression:

(n > 0) ? f : n;

where f is float and n is int. According to C’s type promotion rules, the entire expression evaluates to float regardless of the condition because float has a higher rank than int. This implicit promotion ensures consistency in expression evaluation.

Additional Considerations

  • Use sizeof() to determine data type sizes on different systems.
  • Be mindful of type conversions in mixed arithmetic operations.
  • Explicit casting is preferred when converting between types to avoid surprises.
  • Understand integer overflows, especially when working with large values.

By following these principles, you can write more predictable and portable C code!

Programming in C: Important Points to Remember About Variables

When working with variables in C, it’s crucial to follow best practices and be aware of certain language-specific behaviors. Here are some key points to keep in mind:

1. Avoid Variable Names That Start with an Underscore (_)

  • Variable names beginning with an underscore are often reserved for system and library routines. Using them can lead to unexpected conflicts.
  • Example (should be avoided): int _count = 10; // Might conflict with system-level identifiers
  • Instead, use meaningful names without underscores at the beginning: int count = 10;

2. Case Sensitivity in Variable Names

  • C distinguishes between uppercase and lowercase letters in variable names.
  • Example: int value = 10; int Value = 20; // Different from 'value' printf("%d %d", value, Value); // Output: 10 20

3. Significance of Name Length

  • At least the first 31 characters of an internal identifier (such as a variable or function name) are significant. This means that names longer than 31 characters might be truncated depending on the compiler.
  • Example: int thisIsAVeryLongVariableNameButOnlyFirst31CharactersMatter = 100;

4. External Variable Names and Linkers

  • External names (used in global scope) may be subject to restrictions imposed by the assembler or linker, rather than the C language itself.
  • Example: extern int globalCounter;

5. Character Set and Signedness

  • The C standard guarantees that characters in the machine’s standard printing character set will never have a negative value when stored in a char variable. However, whether char is signed or unsigned by default depends on the compiler and architecture.
  • Example: char c = 'A'; printf("%d", c); // Will always be non-negative for printable characters

Additional Tips:

  • Use meaningful and descriptive variable names to improve code readability.
  • Follow naming conventions, such as using snake_case or camelCase depending on coding standards.
  • Initialize variables before use to prevent undefined behavior.
  • Prefer const or enum over #define for defining constants.

By keeping these points in mind, you can write more robust and maintainable C programs.

Programming in C: A Small Note on Functions

Functions play a fundamental role in C programming, providing modularity, reusability, and better code organization. This article explores some key aspects of C functions, including their behavior, return values, and compilation.

Basic Function Concepts

Standard library functions like printf(), getchar(), and putchar() are commonly used in C. A C function cannot be split across multiple files; each function must be fully defined in one file.

The main Function and Return Values

The main function is the entry point of any C program. It returns an integer value, typically:

  • 0 for normal termination
  • A nonzero value for erroneous termination

Example:

#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0; // Indicates successful execution
}

Function Prototypes and Argument Handling

A function prototype must match its definition and usage. If the number of actual arguments exceeds the number of formal parameters, the extra arguments are ignored. Conversely, if fewer arguments are passed, the missing parameters may contain garbage values.

Example:

#include <stdio.h>

void greet(char *name) {
    printf("Hello, %s!\n", name);
}

int main() {
    greet("Alice", "ExtraArg"); // Compiler warning: too many arguments
    return 0;
}

Variable Scope and Persistence

  • Automatic variables (local variables) do not retain their values across function calls unless declared as static.
  • Static variables retain their values between function calls.

Example:

#include <stdio.h>

void counter() {
    static int count = 0; // Retains value across calls
    count++;
    printf("Count: %d\n", count);
}

int main() {
    counter();
    counter();
    counter();
    return 0;
}

Output:

Count: 1
Count: 2
Count: 3

Return Statements and Garbage Values

A function must return a value if it is declared with a non-void return type. Failing to return a value results in undefined behavior.

Example:

int faultyFunction() {
    // No return statement (causes garbage value to be returned)
}

int main() {
    int value = faultyFunction();
    printf("Returned value: %d\n", value); // Unpredictable result
    return 0;
}

Compilation Across Multiple Files

C allows functions to be spread across multiple source files. Compilation can be done using the gcc command:

$ gcc main.c fun1.c fun2.c -o my_program

This links all object files together to produce the final executable.

Undefined Order of Function Execution

In an expression like:

x = function1() + function2();

The order of execution of function1() and function2() is unspecified. The C standard does not dictate which function gets evaluated first, leading to potential unpredictability in results.

Example:

#include <stdio.h>

int function1() {
    printf("Executing function1\n");
    return 5;
}

int function2() {
    printf("Executing function2\n");
    return 10;
}

int main() {
    int x = function1() + function2();
    printf("x = %d\n", x);
    return 0;
}

Output order may vary, so avoid relying on execution sequence in such cases.

Conclusion

Understanding C functions, their behavior, and proper usage is crucial for writing robust and portable code. Following best practices such as defining proper prototypes, handling return values correctly, and being aware of evaluation order can help avoid unexpected bugs in C programs.

Programming in a UNIX Environment: Essential Commands

Understanding Basic UNIX Commands

UNIX provides a powerful command-line environment where users interact with the system via a shell. Here, we explore some fundamental commands and concepts that every UNIX user should know.

User Identification Commands

who am i

This command displays the current user’s name along with the terminal (TTY), date, and time of login:

$ who am i
john_doe    tty1    Mar 19 10:15

whoami

This command prints only the username of the currently logged-in user:

$ whoami
john_doe

Directory Navigation

In UNIX systems:

  • The parent directory is denoted by ..
  • The current directory is denoted by .

Removing a Directory

  • rmdir <directory_name> removes an empty directory. To remove non-empty directories, use rm -r <directory_name>.

About the Shell

The shell is an ordinary program that interprets commands and executes them. It processes wildcards (like * and ?) before passing arguments to commands.

Using Wildcards in Commands

Wildcards allow flexible pattern matching in filenames.

cat Command and Wildcards

  • cat c* prints the contents of all files starting with ‘c’.
  • The * wildcard represents any string of characters.

echo Command

The echo command prints arguments to the terminal:

$ echo Hello, UNIX!
Hello, UNIX!

Wildcards with echo:

$ echo ch*
changelog checklists chapter1.txt


$ echo *
file1.txt file2.txt script.sh test.c

rm (Remove Files)

  • rm * deletes all files in the current directory (use with caution!).
  • rm *.txt deletes all .txt files.
  • rm te[a-z]* removes all files starting with te followed by a lowercase letter.

Advanced Wildcard Usage

The [ ] brackets specify a range of characters:

$ pr r[1234]*

Prints all files starting with ‘r’ followed by 1, 2, 3, or 4.

The ? wildcard matches exactly one character:

$ ls ?.txt

Lists files that have a single-character name followed by .txt.

Input and Output Redirection

UNIX allows redirecting command outputs using > and <.

Redirecting Output

  • ls > filelist saves the list of files into filelist.
  • cat file1.c file2.c > file3.c merges file1.c and file2.c into file3.c.
  • cat file4.c >> file3.c appends file4.c to file3.c.

Redirecting Input

  • pr -3 < filelist prints the contents of filelist in three-column format.
  • grep main < source.c searches for occurrences of ‘main’ in source.c.

Conclusion

Understanding these essential UNIX commands enhances productivity and efficiency when working in a UNIX-based environment. Wildcards, redirection, and basic command utilities provide a powerful toolkit for managing files, directories, and data. Master these, and you’ll navigate UNIX with ease!