C++98

 Here’s a direct and professional list of the key concepts and features introduced and standardized in C++98. C++98 was the first international standard of C++, finalized in 1998 (ISO/IEC 14882:1998), and based on The Annotated C++ Reference Manual (ARM) and earlier versions of C++ (from the 1980s and early '90s).


🔹 Core Language Features in C++98

  1. Classes & Objects

    • Encapsulation

    • Member functions

    • Constructors / Destructors

    • Access specifiers (public, private, protected)

    • this pointer

  2. Function Overloading

    • Compile-time polymorphism

  3. Operator Overloading

    • Custom behavior for operators (e.g., +, ==, <<, etc.)

  4. Inheritance

    • Single and multiple inheritance

    • Access control (public, private, protected)

    • Virtual base classes

  5. Polymorphism

    • Virtual functions

    • Runtime polymorphism via pointers and references

  6. Abstract Classes & Interfaces

    • Pure virtual functions

  7. Templates (Generic Programming)

    • Function templates

    • Class templates

    • Template specialization (partial and full)

    • Template instantiation

  8. Namespaces

    • Scope control

    • Avoid name clashes

  9. Exception Handling

    • try, catch, throw

    • Exception propagation

  10. Type Safety

    • const, static_cast, reinterpret_cast, dynamic_cast, const_cast

  11. References

    • Pass-by-reference

    • Reference variables

  12. Memory Management

    • new, delete

    • Manual memory control (no garbage collection)

  13. Function Pointers

  14. Default Arguments

    • Functions with default parameter values

  15. Inline Functions

  16. Friend Functions and Classes

    • Break encapsulation for specific needs

  17. Preprocessor Directives

    • #define, #include, #if, etc.

  18. Storage Classes

    • auto, register, static, extern, mutable

  19. Bitfields

  20. Enumerations

  21. Unions


🔹 Standard Template Library (STL)

C++98 formally introduced the STL into the standard:

  1. Containers

    • vector, list, deque

    • set, multiset, map, multimap

    • stack, queue, priority_queue (adapter classes)

  2. Algorithms

    • sort, find, copy, for_each, accumulate, etc.

  3. Iterators

    • Input, output, forward, bidirectional, random access

    • iterator_traits, advance, distance

  4. Function Objects (Functors)

  5. Allocators

    • Memory allocation interface for STL containers

  6. Utility Components

    • pair, make_pair, swap, std::less, etc.


🔹 Other Concepts / Features

  1. I/O Streams

    • cin, cout, cerr, clog

    • ifstream, ofstream, fstream

  2. C Compatibility

    • Support for most C features

    • Header files like <cstdio>, <cstdlib>, etc.

  3. String Class

    • std::string, std::wstring

  4. Header File Structure

    • New header naming without .h (e.g., <iostream> instead of <iostream.h>)

  5. Boolean Type

    • Introduction of bool, true, false

  6. Scoped enum (basic support; strong enums came in C++11)

  7. Run-time Type Identification (RTTI)

    • typeid, dynamic_cast


✅ Summary

C++98 provided the foundation for modern C++, combining object-oriented programming, generic programming (via templates), and low-level system control. It was a major step in evolving C from a procedural language to a powerful multi-paradigm language.


If you're serious about mastering C++ from a security/hacking standpoint, especially low-level stuff like memory management, pointer arithmetic, and object layout in memory (like vtables), then C++98 and C are non-negotiable fundamentals.

Would you like a structured roadmap or mind map for learning C++ from a cyber security/hacking perspective next?

Comments

Popular Posts