Naming convention, witch do you prefer ?

lets say foobar is a class

That depends on what the identifier is for.


Different conventions for:

MACROS

variables
member variables
static member variables
global variables
local variables

functions
global functions
static functions
methods
static methods

Types
Class
you get the idea.

Some of these overlap for me.

He said foobar was a class name (Yes, it varies for me as well)

FooBar for classes... Camel notation for most else

I use FooBar for classes, class methods, and functions. Camel for everything else, like THM.

moved to the general c++ forum since its not really a help topic. anyway for a class id use FOOBAR. im finding that i like types to be capitalized and then the object lowercase. i do all sorts of things with functionnames though

FOOBAR for macros, FoObAr (or, like a sane person FooBar) for classes, functions, variables and members.

class id? you mean class name? though one can use any naming convention for naming classes, functions etc but using upper case for macros and constants is followed almost universally in c++ fraternity. so anything *other than* all-upper-case could be used for the class names etc. ofcourse, "underhanded names"(ones that begin with an underscore or that contain a double underscore) should NEVER be used.

I like CFooBar
Normally I like to have the first letter of the type lower case but in this case its better to keep the C upper case since thats what a lot of the classes use.
And then I like to captialize each word.

I dislike hungarian notation fore some reason. It kakes the names of everything more confusing when I can just place my mouse over the variable name to figure out it's type. It I were using notepad, I would consider using hungarian notation.

Makes things more confusing? How so? I find it better as soon as you look at a variable you instantly know the type and general function of it and don't have to go around finding what type it is.

Hungarian Notation is dead - even in microsoft circles.

Herb Sutter says: "it has mixed utility in type-unsafe languages(like C), it is possible but has no benifits (only drawbacks) in object-oriented languages(like smalltalk), and it is impossible in generic programming. Therefore, no C++ programmer should use Hungarian notation."

it has mixed utility in C like languages because: 1.(adv)it helps in identifying the type immediately by looking at the variable 2.(disadv)but when the type of a variable changes, it is not likely that you are going to hunt through all the code and change all occurrences of its name. For an example of this, look at the documentation for wParam in Microsoft Windows 32-bit: It changed from a 16-bit value (w stands for word) to a 32-bit value (which should have been dwParam)

in OO languages, variables are typeless - they contain an object, the type of which depends on the object itself, not the variable.

in generic code, ofcourse, hungarian notation is just impossible.

actually it was class i would- contraction and forgot the ' so it would have been i'd but ya for the class name, and struct names i like to have uppercase, the reason is i like to retain in my short term memory what is an object, what is a class, what is a variable, what is a function. im finding i like to take advantage of c++'s case sensitive nature, so at a glance i can tell whats what (the case sensitive id's are very good for parameters of a function)

actually it was class i would- contraction and forgot the ' so it would have been i'd but ya for the class name, and struct names i like to have uppercase, the reason is i like to retain in my short term memory what is an object, what is a class, what is a variable, what is a function. im finding i like to take advantage of c++'s case sensitive nature, so at a glance i can tell whats what (the case sensitive id's are very good for parameters of a function)

And I want to remeber what is a macro, what a class and what a variable:

MACROFOO
ClassFoo
var_foo
func_foo() or FuncFoo() or funcFoo()

It's no problem to seperate all 4 things using there names. A special convention for functions is useless because they are the only which are followed by a (.

i dislike the hungarian notation cause it just looks plain ugly too me
and i can't decide witch looks better to me
class_foo::funct_foo
or
ClassFoo::FunctFoo