Back CSE 240 | The Complete Guide Programming
Download Open
Show description 2,377 chars · Programming

CSE 240 | The Complete Guide

CSE 240 | The Complete Guide









CSE 240: The Guide

Mastering C, C++, and Core Programming Concepts









Module 1: Foundations

Module 2: Data & I/O

Module 3: Pointers & Structs

Module 4: Memory & Files

Module 5: Recursion

Module 6: OOP









Module 1: Foundations & Paradigms


Programming Paradigms

A paradigm is a model or pattern for how we express computation. The two main branches are Imperative (how to execute) and Declarative (what to execute).


Imperative/Procedural: The classic approach. You provide a step-by-step sequence of commands that change the program's state. (e.g., C, FORTRAN)

Object-Oriented (OOP): An extension of imperative programming. Data and the code that operates on that data are bundled into "objects". (e.g., C++, Java, C#)

Functional/Applicative: Treats computation as the evaluation of mathematical functions. It avoids changing state and mutable data (no side-effects). (e.g., Scheme, LISP)

Logic/Declarative: You define a set of facts and rules. The computer uses logic to figure out the solution. The focus is on the goal, not the algorithm. (e.g., Prolog)






Program Structure & Errors

Programs are analyzed in layers, from basic symbols to their ultimate meaning. Errors can occur at different stages.


Lexical: The basic building blocks (tokens) like keywords (int), identifiers (myVar), and operators (+).

Syntactic: The grammar rules. Does if (x > 0) follow the language's structure?

Contextual: The rules beyond grammar. Did you declare a variable before using it? Are the types compatible (e.g., you can't add a string to an integer without conversion)? Type checking happens here.

Semantic: The runtime meaning. A classic semantic error is division by zero. The code might be syntactically and contextually correct, but its behavior is invalid.






Macros vs. Functions

Both macros and functions are ways to reuse code, but they work very differently.

A macro is a preprocessor directive. It's a simple text substitution that happens *before* compilation. It's like a find-and-replace for your code.

// Macro definition
#define MAX(x, y) ((x) > (y) ? (x) : (y))

int a = 5, b = 10;
int m = MAX(a, b); // Preprocessor changes this to: int m = ((a) > (b) ? (a) : (b));

Pros: Faster execution as there is no function call overhead.…