Object-Oriented C Language

An example project implementing object-oriented programming paradigms using pure C.

---

You can view the translation in your preferred language by clicking on the corresponding link below.

🌍 English | 한국어 | 中文 | 日本語 | Русский | Français | Español | Italiano | Português | हिन्दी | العربية

---

📖 Overview

This project is an example that implements key concepts of object-oriented programming (abstraction, encapsulation, inheritance, polymorphism) in a modular structure using only the C language (C99 standard). Various system components (System), threading (Thread), console I/O (Console), input scanning (Scanner), and algorithms (Algorithm) are expressed as objects using structs and function pointers.

⚙️ Key Features

• System: Basic I/O, file I/O, timer, platform abstraction
• Thread: Lightweight thread creation and management
• Console: Console I/O formatting and control
• Scanner: Input stream utilities
• Algorithm: Stack, Queue, Deque, List collections

🧰 Tech Stack

Badge	Description
	C Language: C99 standard, Object-Oriented Programming implementation using structs and function pointers
	GCC: GNU Compiler Collection, used for building C programs
	Make: Build automation tool used for compiling and linking source files
	Makefile: Configuration file used by Make for specifying build instructions
	Windows API: Windows system functions and multithreading support (windows.h, conio.h, process.h)
	Linux: Open-source operating system widely used in programming and development
	macOS: Operating system used for Mac hardware with Unix-like commands
	POSIX Threads: pthread.h, used for multithreading in Unix-based systems
	C Standard Library: Core libraries including stdio.h, stdlib.h, string.h, time.h
	OOP in C: Encapsulation, abstraction, and polymorphism via structs and function pointers
	Algorithms: Implementations of data structures like stack, queue, deque, and list
	Git: Version control system for managing code changes
	GitHub: Platform for version control and collaboration, enabling sharing and review of code
	Vim: Highly configurable text editor for efficient text editing
	Visual Studio: IDE for C/C++ development with powerful debugging, code analysis, and testing tools
	Visual Studio Code: Source code editor used for writing and debugging
	CLion: JetBrains' C/C++ IDE, with powerful code analysis, refactoring, and CMake integration

🖥️ Platform Compatibility

This project has been tested and runs on the following platforms:

• 🪟 Windows 10 / 11
• 🐧 Linux
• 🍎 macOS

🛣️ Roadmap

• Object-Oriented Programming in C
• Thread and Mutex abstraction
• Console I/O utilities
• Input Scanner for primitive types
• Data Structures: Stack, Queue, List
• Advanced File utilities
• GUI Layer using SDL or ncurses (Planned)

🏗️ OS-Specific Build Instructions

🪟 Windows (GCC MinGW)

gcc -std=c99 -Wall -I inc -o main.exe src/*.c
main.exe

🪟 Windows (MSVC Command Prompt)

cl /I inc /Fe:main.exe src\*.c
main.exe

🐧 Linux / 🍎 macOS

gcc -std=c99 -Wall -I inc -o main src/*.c -lpthread
./main

Note: -lpthread is required for multithreading support.

📂 Directory Structure

Object-Oriented-C-Language/
├── inc/                      # Header files
│   ├── algorithm.h
│   ├── console.h
│   ├── main.h
│   ├── Scanner.h
│   ├── System.h
│   └── thread.h
├── src/                      # Source files
│   ├── algorithm.c
│   ├── console.c
│   ├── main.c
│   ├── Scanner.c
│   ├── System.c
│   └── thread.c
├── translations/             # Translation files
│   ├── ar.md                 # Arabic
│   ├── es.md                 # Spanish
│   ├── fr.md                 # French
│   ├── hi.md                 # Hindi
│   ├── it.md                 # Italian
│   ├── ja.md                 # Japanese
│   ├── ko.md                 # Korean 
│   ├── pt.md                 # Portuguese
│   ├── ru.md                 # Russian
│   └── zh.md                 # Chinese
├── LICENSE                   # License information
└── README.md                 # Project description (this file)

🔧 Development & Build

Requirements

• GCC (version ≥ 4.8)
• Make (optional)

Manual Compilation

# From the project root directory
gcc -std=c99 -Wall -I inc/ -o main src/*.c

Sample Makefile

CC = gcc
CFLAGS = -std=c99 -Wall -I inc
SRCS = $(wildcard src/*.c)
OBJS = $(SRCS:.c=.o)
TARGET = main

all: $(TARGET)

$(TARGET): $(OBJS)
	$(CC) $(CFLAGS) -o $@ $^

%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

clean:
	rm -f src/*.o $(TARGET)

🚀 How to Run

# After build
./main

The sample will automatically create objects, invoke methods, and test threads.

📑 API Structure

1. System & Basic Types

• SYSTEM out

  • out.printf(const string format, ...) : Formatted output
  • out.println(const string format, ...) : Formatted output with newline

• SYSTEM in

  • in.read() -> int32_t : Read a character as integer from stdin

• File

  • Constructor: File new_File(const string path, const string mode)

  • Methods:

    • f.scanf(const string format, ...) : Formatted input from file
    • f.printf(const string format, ...) : Formatted output to file
    • f.println(const string format, ...) : Output with newline
    • f.open(const string path, const string mode) : Open file
    • f.close() : Close file
    • f.readLine() -> string : Read one line from file

• Time

  • Constructor: Time new_Time(void)

  • Methods:

    • t.getSystemTime(Time* t) : Get current system time
    • t.getTime(Time* t) : Get internal time value
    • t.setTime(...) : Set time (year, month, day, hour, minute, second)
    • t.start() / t.stop() : Timer thread control

• Primitive Wrapper Constructors

  • new_String(string s)

    • Methods: s.length(), s.charAt(index), s.substring(start, end), s.equals(...), s.toCharArray()
    • Static: String.valueOf(...), String.format(...)

  • new_Character(char c)

    • Methods: c.charValue(), c.equals(...), Character.isDigit(char), Character.isLetter(char)

  • new_Byte(...), new_Short(...), new_Integer(...), new_Long(...), new_Float(...), new_Double(...), new_Boolean(...)

    • Common methods: x.getValue(), x.toString(), x.equals(...), x.compareTo(...)
    • Static: Wrapper.parse<Type>(...), Wrapper.valueOf(...)
    • Byte-specific: b.byteValue(), b.toUnsigned(), Byte.parseByte(string, base)
    • Boolean-specific: b.booleanValue(), b.isTrue(), b.isFalse(), Boolean.parseBoolean(...)

2. Thread & Mutex

• Thread

  • Constructor: Thread new_Thread(void* (*function)(void*))

  • Methods:

    • start(...), join(), detach(), cancel(), exit(), delete()

• Mutex

  • Constructor: Mutex new_Mutex()

  • Methods:

    • lock(), unlock(), delete()

3. Console

• Console

  • Constructor: Console new_console(void)

  • Methods:

    • print(...), println(...), readLine(), clear()
    • setColor(ColorType color), resetColor(), kbhit() -> int

4. Scanner

• Scanner

  • Constructor: Scanner new_Scanner(struct __stdin_t in)

  • Methods:

    • nextChar(), nextByte(), nextShort(), nextInt(), nextLong()
    • nextUByte(), nextUShort(), nextUInt(), nextULong()
    • nextBoolean(), nextFloat(), nextDouble(), nextLDouble()
    • next() -> string, nextLine() -> string

    (By default, uses whitespace as delimiter and supports line reading.)

5. Collections (Algorithm)

• Stack

  • Constructor: Stack new_stack(size_t elementSize)
  • Methods: push(...), pop() -> void*, clear(), delete()

• Queue

  • Constructor: Queue new_queue(size_t elementSize)
  • Methods: push(...), pop() -> void*, clear(), delete()

• Deque

  • Constructor: Deque new_deque(size_t elementSize)
  • Methods: pushFront(...), pushBack(...), popFront(), popBack(), clear(), delete()

• List

  • Constructor: List new_list(size_t elementSize)
  • Methods: add(...), get(index), remove(index), size(), clear(), delete()

🛠️ Contribution Guide

1. Fork this project
2. Create a feature branch: git checkout -b feature/YourFeature
3. Implement the feature
4. Write tests and update docs
5. Create a Pull Request

Please open an issue first to discuss your ideas before contributing.

📄 License

This project is licensed under the MIT License.