Forem: ib-dev-cpp

From #cpp to #flutter: My Go-To #developertip for Sanity

ib-dev-cpp — Sun, 06 Jul 2025 16:14:34 +0000

Let's be real, a huge part of #coding is managing complexity. We juggle logic, state, and deadlines. But what if the language itself is adding to the weight?

The #cpp World: Raw Power, High Stakes

I was recently deep in some #cpp code. It’s a beast—unbelievably powerful for performance-critical tasks. But it asks a lot from you.

Remember this pattern?

// You are in complete control... for better or worse.
std::vector<int>* createNumbers() {
    auto* numbers = new std::vector<int>(); // Manual allocation
    numbers->push_back(10);
    numbers->push_back(20);
    return numbers;
}

// And you must remember to clean up your own mess.
// delete myNumbers;

This code gives you fine-grained control, but it's a contract. You are responsible for every new and delete. One slip-up can lead to memory leaks and hours of debugging.

The #dart & #flutter World: Power with Guardrails

Then, I switched contexts to a #flutter project. Flutter runs on #dart, and the difference in mental overhead was night and day.

Here’s the same logic in Dart:

// Simple, clean, and safe.
List<int> createNumbers() {
  final numbers = [10, 20];
  return numbers;
}

// The garbage collector is your friendly neighborhood cleaner.

No pointers. No manual memory management. It’s built with safety features like a world-class garbage collector and sound null safety. This is the foundation that makes building beautiful, complex UIs in #flutter feel so productive.

My MAIN #developertip: Match Your Tool to Your Task

This brings me to my number one tip for any developer working across different tech stacks:

Actively choose your level of abstraction.

When you're writing #cpp, you're often choosing low-level control for maximum performance. You accept the cognitive load as part of the deal.
When you're writing #dart for a #flutter app, your goal is a fantastic user experience. Dart's design intentionally abstracts away low-level worries so you can focus on widgets, state management, and animations.

Don't just see Dart's simplicity as "easier." See it as a strategic choice that frees up your brainpower for what truly matters in that context: the user.

Great #programming isn't about always using the "most powerful" language. It's about picking the tool that makes you the most powerful for the task at hand.

A NEW REGEX ENGINE IS HERE!

ib-dev-cpp — Fri, 11 Nov 2022 21:49:51 +0000

In the last week, I've been working on a new regex engine called Mregex, a free and open regular expression engine and still under development.

Enough talking let's explore its features.

As any regex engine it supports the following:

sub-expressions:

#include <Mregex.h>

int main ( void ) {
    char regex [] = "(he), \0llo", str [] = "he, hello";
    short c = Regex ( regex, str, NULL, 0 );
    // Will return SUCCES
}

the above code has defined two strings the regex string which
has one expression that will match "he" and then will match
", " and then will match the first sub-expression again and
then will match the "llo".

Anchors: ^: will match the beginning of the string or the beginning of the line in multi-Line mode ( more on that later). $: will match the ending of the string or the ending of the line in multi-Line mode

#include <Mregex.h>

int main ( void ) {
    char regex [] = "^ $", str [] = " ";
    short c = Regex ( regex, str, NULL, 0 );
    // Will return SUCCES
}

Character class:
[char-group]: Match any single character in the char-group.
[start-end]: Char range: Match any character between the start and end in the ASCII Table.
. : Match any single character in the ASCII table instead '\n' and NULL Byte
Quantifier:
*: Match the previous element zero or more times
+: Match the previous element one or more times
?: Match the previous element zero or one time
{min, max}: Match the previous element min times or more but no more than max
Modes:
NoCase: use it whit case insensitive
NoWhit: ignore all the white spaces
MultiLine: Use multiline mode, where ^ and $ match the beginning and end of each line (instead of the beginning and end of the input string)

The Regex function

The Regex function has 4 parameters
the first parameter is the regex string
the second parameter is the text string (the string to be matched)
the third parameter is not yet implemented
the fourth parameter is the modes where it can be ( 0 or NoCase | NoWhite)

Regex ( regex, str, NULL, MultiLine | NoWhite )

IMPORTANT: Whenever you use '.+' or '.*' make sure that the next character is a valid character or escaped character like '(' or 'v' but MAKE SURE IT'S NOT '('

So, what are you waiting for, go ahead and try it out.
Found a bug Let us know at modernbinaryutility@gmail.com

Platform detection in C&C++

ib-dev-cpp — Sat, 07 May 2022 15:29:03 +0000

sometime when writing c or c++ code you need to write a code specific to the compiler/OS. and to this job the compiler have some predefined macros to detect the compiler or the OS.

Checking for OS:

to check which platform the code is compiled use these predefined macros:

for Windows              :  _WIN32
for Windows 64 bit       :  _WIN64 ( _WIN32 included )
for Mac OS & IOS         :  __APPLE__
for Linux & Linux-derived:  __linux__
for Android              :  __ANDROID__ ( __linux__ included )
for Akaros               :  __ros__
for NaCL                 :  __native_client__
for AsmJS                :  __asmjs__
for Fuschia              :  __Fuchsia__

Checking for Compiler:

to check wich compiler used:

Visual Studio       _MSC_VER
gcc                 __GNUC__
clang               __clang__
emscripten          __EMSCRIPTEN__ (for asm.js and webassembly)
MinGW 32            __MINGW32__
MinGW-w64 32bit     __MINGW32__
MinGW-w64 64bit     __MINGW64__