in c++, where do consider saying that you know the "basics of c++"? would you consider knowing the basics when you can use pointers? or when you know how to use classes?

Basic: Complete language syntax. OOP (all of it). Standard library. All of those are fundamentals.

Advanced: Templates and meta-programming, low level concepts such as direct memory management, cross-platform portability, advanced topics in function pointers.

Guru: Complete and utter understanding of entire standard, and fully proficient with all compilers and platform quirks for major OSes, and several versions in the past.

That goes for a programmer. For slightly less specialized environments, I guess pointers and classes will do.

For a designer/architect and all those other fancy titles, expert familiarity with at least one major OS. WinAPI/MFC/ATL/several_more, for example.

example use of pointers:

int x = 5;
int *y;

y = &x

*y = 7; // now x is 7 too :-)

I'm wondering when I would ever need to state that I know the "basics" of a language... If I saw that on a resume and I was the hiring manager, I'd pass, because that sounds like someone who doesn't know the language is trying to front like he does. In my mind, you either know the language or you don't.

Your level of expertise with a language is really measured by the simplicity and elegance with which you can solve various problems in it. Simplicity refers to code brevity - the less scaffolding you need to write (most likely because you know its standard library and high-quality third party libraries well), the fewer statements you need to express a concept (because you understand the language's operations, side-effects and ancillary behaviors), etc - without sacrificing clarity. Your code should be readable to anyone who knows the language without excessive commenting. In fact, reserve your commenting for explaining things that can't be gleaned from the code - whys instead of hows.

Elegance is comprehensiveness, covering all bases, while maintaining simplicity. Elegance is really an expression of good design; elegant code handles all the edge cases without requiring a bunch of special-case code.

You can trivially evaluate your level of knowledge using these two yardsticks. If you need to write extra code to handle oddities, your code is less elegant - probably drop from advanced to intermediate. If you need to write a bunch of setup code when your objective isn't to write a setup library, your code is not simple - knock yourself down a notch from intermediate.