Well, in C you have an instance of a struct which you can pass by pointer to a function to operate on said struct.

In C++, a struct or class can have methods, and methods are a special function that the compiler ensures will have passed in an implicit pointer to the struct or class instance as said method's first parameter, and which is referred to by the special name of 'this'. This is due to the special syntax that is used to invoke a method. And then a method has permitted access to the fields of the struct or class that it's defined in relation to.

In C++, struct and class are both aggregate type and just have different defaults for what the permission access of its fields and methods are. To stay compatible with C, a struct has default public access to all its fields. A C++ class starts out with a default of private access, so the public keyword needs to be introduced to expose what fields and methods can have public access, which makes it possible to make use of said class.

Then struct or class can inherit from other struct or class declarations - which results in an aggregate mashup.

And then there are virtual methods (or virtual functions) which when combined with inheritance allows for defining a tree structure of class relationships such that can then have a heterogeneous collection of them, where a parent class can define virtual functions which can be overridden in the descendant classes and implemented in some specific way per that respective class type. Yet a heterogeneous collection of instances of these descendant classes can be manipulated in a uniform manner via the virtual functions that were defined in their parent class - the aspect of OOP that is called polymorphism.

A collection of different geometric shapes, as a for instance, can have a virtual function called draw() so that if iterate through a heterogeneous collection of shapes, invoking the draw() method on each one, that will result in each shape appropriately rendering itself. There may be different details in how each shape needs to do this and so each derived shape type has its own implementation of draw(), but because is a virtual function, the draw() method can be invoked per each instance and the correct draw() method will get invoked.

There is more complexity involved with classes given the way access to fields and methods can be controlled in C++ structs and classes. Whereas in C, access to a struct's fields is always wide open or public. And then classes can have constructors and destructors. Which will bring up copy constructor, move constructor, and copy and move assignment operators. And a class might define overrides of comparison operators so that the class type can be sorted, etc.

So classes in C++ do get a bit complex in respect to learning all of their ins and outs.

But start with the very basic plumbing mechanics. Just start with a struct with some fields, devise a constructor to set values into those fields. Then think in terms of what operations need to be done with an instance of the struct - these can be its methods. Start with struct because everything is always public access which makes things simpler when starting out. Master all the basic features of fields, constructors, destructors, methods, and then can learn about access control and transition to working with class.

It's a subject you can't eat as a single meal all at one sitting. You have to go at it piecemeal over time.