All answers so far have focused the topic of your question as you stated, which is what the difference between c and c++. In reality it sounds like you know what difference is, you just don't understand why you would need it. So then other answers attempted to explain OO and encapsulation.
I wanted to chime in with yet another answer because based on the details of your question, I believe you need to take several steps back.
You don't understand the purpose of C++ or OO because to you it seems, that your application simply needs to store data. This data is stored in variables. Why would you want to make a variable inaccessible since then you can't access it? By making everything public, or better yet global, you can read data from anywhere and there's no problems. And you are right, based on the scale of the projects you are currently writing, there's probably not that many problems (or there are, but you just haven't become aware of them yet).
I think the fundamental question you really need to have answered is why would you ever want to hide data since if you do that, you can't work with it? And this is why...
Let's say you start a new project, you open text editor and you start writing functions. Every time you need to store something and remember it for later, you create a variable. To make things simpler, you made your variables global. Your first version of your app runs great. Now you are adding more features. You have more functions, certain data you stored from before you need to read in your new code. Other variables you need modify and you keep writing more functions. What you may have noticed (or you absolutely will in the future) is as your code gets bigger, it takes you longer and longer to add the next feature. And as your code gets bigger, it becomes harder to add features without breaking something that used to work. Why? Because you need to remember what all your global variables are storing and you need to remember where all of them are being modified. And you need to remember which function is ok to call in what order and if you call them in a different order, you might get errors because your global variables aren't quite valid yet. Have you ever run into this?
How big are your typical projects (lines of code)? Now imaging a project 5000 to 50000 times as big as yours. And there are multiple people working in it. How can everyone on the team remember (or even be aware of) what all those variables are doing?
What I described above is an example of a perfectly coupled code. And since the dawn of time (assuming time started Jan 1, 1970) human kind has been looking for ways to avoid these problems. The way you avoid them is by splitting up your code into systems, subsystems and components and limiting how many functions have access to any piece of data. If I have 5 integers and a string that represent some kind of state, would it be easier for me to work with this state if only 5 functions set/get the values? or if 100 functions set/get these same values? Even without OO languages (i.e. C for example), people have been working hard on isolating data from other data and making clean separation boundaries between different parts of the code. When the project gets to a certain size, ease of programming becomes not, "can I access variable X from function Y", but "how do I make sure ONLY functions A, B, C and no one else is touching variable X"
This is why OO concepts have been introduced and this is why they are so powerful. They allow you to hide your data from yourself and you WANT to do it on purpose because the less code that sees that data, the less chance there is that when you add the next feature you will break something. This is the main purpose for the concept of encapsulation and OO programming allows you to break down your systems/subsystems into even more granular boxes to a point where no matter how big overall project is, given set of variables may only be accessed by 50-200 lines of code and that's it! There's obviously much more to OO programming, but in essence this is why C++ gives you options of declaring data/functions as private, protected or public.
The next greatest idea behind OO is the concept of abstraction layers. Although procedural languages can also have abstractions, in C, a programmer must make a conscious effort to create such layers, but in C++ when you declare a class, you automatically create an abstraction layer (it's still up to you whether or not this abstraction will add or removes value). You should read/research more about abstraction layers and if you have more questions, I'm sure this forum will be more than happy to answer those as well.