In my view, it's not so much a definitional issue as a usability issue.
Objects are an abstraction intended to make it easier to read, write, and reason about complex programs. For a practical programmer, whether a language meets all the criteria of a particular formal definition of "object-oriented" (there seem to be several competing ones!) isn't really as important as whether the tools it offers are suitable for thinking about your program in terms of said objects -- i.e., actually reaping the supposed productivity benefits of OOP.
In C++, objects are a terribly leaky abstractions, often forcing programmers to wrangle with nasty issues related to how those objects are structured in memory -- issues that are more reminiscent of coding in straight C than other OOP languages. For example, C++ Frequently Questioned Answers offers this criticism (among others):
It is very beneficial for a practitioner to gain familiarity with OO
systems other than C++, and with OO definitions other than the
"encapsulation, inheritance, polymorphism" trinity interpreted in
special ways allowing C++ to be considered "OO". For example, a claim
that an environment lacking boundary checking or garbage collection is
not an OO environment sounds outrageous to people accustomed to C++.
But from many perspectives, it makes a lot of sense. If anyone can
overwrite an object, where's the "encapsulation"? If disposing an
object can lead to dangling references or memory leaks, how is the
system "object-oriented"? What about the ability to tell what kind of
object is located at a given place and time? You say the software
works with objects - where are they? And if one can't find out, how is
one supposed to debug the software?
C++ is object-oriented, but unpleasantly and incompletely: its users have to devote a lot of effort to making sure their data actually behaves like "real" objects rather than errant bits. That said, lots of code has been written in C++ over its lifespan, most of it making use of classes and dynamic dispatch, so it's self-evidently something that you can use for practical OOP.