I was searching on the GitHub for a simple compression library and I came across zip lib. Its a minimal wrapper on top of miniz library.

I have generated the object file successfully but when I came across examples then I got confused by this one.
I have an idea that they are used just to make code look better but can there be any other reason that the developers of zip used these brackets?

You might also be interested in learning about the Dangling Else clause.

For the 2 obvious reasons:

- Code is documentation. Writing code in logical blocks makes it clear the lines of code are related.

- RAII. RAII. RAII. And maybe some RAII.

In C++ (and even other languages), you make it so objects can never exist in an invalid state. You do this by creating an object with a constructor that has all the required data passed to it. A connection object, is given the URL, port, etc--all it needs. And it either FAILS (and yields a null, or throws an exception), or it's a real object.

The second step of RAII? Getting rid of the object when you're done. RAII returns a resource whenever the object is deleted. Like... when it leaves the stack.

void my_function()
   {
   //code
   
      {
      auto c = new connection("192.168.1.1", 80);
      c.send_data("Hello world.");
      } //closes connection. automatically. zero calls. 
//zero room for user error like forgetting
   
   //more code
   }

Other languages actually recognize this pattern so often that they make it an actual construct.

It's typically named with() or using().

with(auto c = new connection("192.168.1.1", 80))
  {
  c.send_data("Hello world.");
  }

Additionally, with/using also allows you to embed another scope. So:

with(auto c = new connection("192.168.1.1", 80))
  {
  // all of c's namespace is assumed / added to the block 
  // and tried for name resolution.
  send_data("Hello world."); // no need for c.
  }

That's really nifty when you have a really long one like

with(my.object.long.deference.c)
    {
    taco();  //calls my.object.long.deference.c.taco()
    }

https://github.com/liballeg/allegro5/blob/master/examples/ex_physfs.c

Katko, your RAII is leaking like a sieve

EDIT
https://www.allegro.cc/forums/thread/610216/954770#target

It's not the RAII that is leaking. It's the lack thereof. In any case, it looks like the OP's snippet is C so RAII doesn't apply and will likely only confuse the OP.

I wrote it at like 3 am, cut me some slack.

The point still stands. I never said it was functional code.

Which I am.

He said the construct. That construct exists in many languages.

Just use 7Zip to make a zip file, then embed your object into your executable and use PhysFS to load it.

Edit
Katko that was bad code either way because if you're looking for certain effects in your destructor who knows when they would be called with a GC. The whole point of RAII is to clean up when you're done, not when the GC gets around to it.

In my Deluxe Pacman 2 game, I have all my resources inside a ZIP file, complete with folders in it etc... to organize the data. I renamed the .zip extension as .pak, but you can use whatever you wish, doesn't have to be .zip. I then use Allegro 5 with PhysFS to load in my resources as needed like you would any other file. It's really quite simple.

I recently released the source code to my Deluxe Pacman 2 game, it is written in C (not C++), and uses only Allegro 5. If you're curious, you can download it. PhysFS is pretty simple to use thanks to Allegro 5.

It's at my website anyhow, the game and below the download for it, is the source code.

https://nitehackr.github.io/games_index.html

if you download the game itself, it contains the .PAK file which is the renamed ZIP, you can open it with something like 7ZIP easy and examine, extract all the data etc. It's all I did to create it.

As an aside, Python comes with a built-in zip encoder that I use for my projects. At the top of your script:

import zipfile

Then, when you get around to writing those files into a zip PhysFS can read, do this:

with zipfile.ZipFile(archive, 'w', zipfile.ZIP_DEFLATED) as z:
   for f in [files to write]:
       z.write(f)

This has saved me a lot of time, because I can just keep a folder of project content and run a script every time I want to update what's in the program.

I've thought about uploading this to my github, but then I'd have to write documentation on it, which nobody likes to do.