C++ idioms by example (Nov 2008)

C++ Idioms by Example, lesson 1
I
Introducing some very basic C++ idioms, rules, guidelines and best practices
h
a

Olve Maudal
oma@pvv.org

November 2008

Disclaimer: most of the items I will discuss here are indeed idioms and conventions of the C++ language, something that most experts will
agree on. However some of the items are based on an ecolect – a programming style that is unique for a limited group of developers. There
are also a few items based on my idiolect, which is a programming style that I believe in. And you may argue that one or two things I
suggest here are just plain idiotic...

My intention is not to tell you how to do C++ programming. I hope to use this presentation as a catalyst for discussion, therefor I have also
included some controversial issues.

Ignite your flamethrower. Choose your battles!

Please criticise this program.

~/myprog/foo.hpp ~/myprog/foo.cpp
namespace bar { #include <iostream>
class Foo { #include "foo.hpp"
int _value;
int my_magic(int a, int b); using namespace std;
public:
Foo(int seed); namespace bar {
int calc(int number = 7); Foo::Foo(int seed) {
int getValue() { _value = seed;
return _value; }
}
void print(char* prefix); int Foo::my_magic(int a, int b) {
}; return a + b - 3 + 8 - 5;
} }

int Foo::calc(int number) {
int result = my_magic(_value, number);
_value += result;
~/myprog/main.cpp return result;
}
#include "foo.hpp"
void Foo::print(char *prefix) {
int main() { cout << prefix << _value << "n";
bar::Foo foo(2); }
char * prefix = "the answer="; }
for(int i=0; i<4; i++) {
foo.calc(i);

Please criticise this program
}
foo.print(prefix);
return 0;
} Spend 5-10 minutes to read through the code. Imagine that this is a piece of code that
you found in a larger codebase. Criticise everything you see,

... apart from the fact that it is a contrived, incorrect and stupid program that does not
do anything useful, and is probably better written in Python as print “the
$ cd ~/myprog answer=42” (and do not spend time on the implmentation of my_magic)
$ g++ foo.cpp main.cpp && ./a.out
the answer=43

What do you see in this code?

Happiness?

I see trouble.

It looks like the code has been written by someone
with little experience in C++, or even worse, by
someone who does not care...

Large amount of this kind of code will make your
codebase rot.

But, once you start to believe - it is time to defeat the
deteriorating agents

int _value;
public:
return _value; }
}
}; return a + b - 3 + 8 - 5;
} }

_value += result;
}
#include "foo.hpp"
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

$ cd ~/myprog
$ g++ foo.cpp main.cpp && ./a.out
the answer=43

1. always compile with high warning level, and treat warnings as errors

int _value;
public:
return _value; }
}
}; return a + b - 3 + 8 - 5;
} }

_value += result;
}
#include "foo.hpp"
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

$ cd ~/myprog
$ g++ -Wall -Wextra -pedantic -Werror foo.cpp main.cpp && ./a.out
the answer=43

2. always use tools to support the building process

int _value;
public:
Foo(int seed);
~/myprog/Makefile
int calc(int number = 7);
namespace bar {
Foo::Foo(int seed) {
return _value; CPPFLAGS=-Wall -Wextra } -pedantic -Werror
} LDFLAGS=
}; return a + b - 3 + 8 - 5;
} all: myprog }

myprog: foo.o main.o int result = my_magic(_value, number);

~/myprog/main.cpp $(CXX) -o $@ $(LDFLAGS) $+ result;
_value +=
return result;
}
#include "foo.hpp"
clean: void Foo::print(char *prefix) {
int main() { rm -f foo.o main.o myprog prefix << _value <<
cout << "n";
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

$ cd ~/myprog
$ make
$ ./myprog
the answer=43

3. do not _prefix member variables, use postfix_ if you must

int _value;
public:
return _value; }
}
}; return a + b - 3 + 8 - 5;
} }

_value += result;
}
#include "foo.hpp"
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

3. do not _prefix member variables, use postfix_ if you must

int value_;
public:
int getValue() { value_ = seed;
return value_; }
}
}; return a + b - 3 + 8 - 5;
} }

int result = my_magic(value_, number);
value_ += result;
}
#include "foo.hpp"
int main() { cout << prefix << value_ << "n";
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

4. public stuff should be declared first, then the private stuff

int value_;
public:
int getValue() { value_ = seed;
return value_; }
}
}; return a + b - 3 + 8 - 5;
} }

value_ += result;
}
#include "foo.hpp"
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

4. public stuff should be declared first, then the private stuff

public:
Foo(int seed); using namespace std;
int getValue() { namespace bar {
return value_; Foo::Foo(int seed) {
} value_ = seed;
void print(char* prefix); }
private:
int value_; int Foo::my_magic(int a, int b) {
int my_magic(int a, int b); return a + b - 3 + 8 - 5;
}; }
}
value_ += result;
}
#include "foo.hpp"
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

5. single argument constructors should usually be explicit

public:
Foo(int seed); using namespace std;
} value_ = seed;
private:
}; }
}
value_ += result;
}
#include "foo.hpp"
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

5. single argument constructors should usually be explicit

public:
explicit Foo(int seed); using namespace std;
} value_ = seed;
private:
}; }
}
value_ += result;
}
#include "foo.hpp"
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

6. initialize the state of the object properly

public:
} value_ = seed;
private:
}; }
}
value_ += result;
}
#include "foo.hpp"
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

6. initialize the state of the object properly

public:
return value_; Foo::Foo(int seed) : value_(seed) {
} }
void print(char* prefix);
private: int Foo::my_magic(int a, int b) {
int value_; return a + b - 3 + 8 - 5;
int my_magic(int a, int b); }
};
} int Foo::calc(int number) {
value_ += result;
return result;
~/myprog/main.cpp }
#include "foo.hpp" void Foo::print(char *prefix) {
cout << prefix << value_ << "n";
int main() { }
bar::Foo foo(2); }
char * prefix = "the answer=";
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

7. use a consistent naming convention, camelCase or under_score

public:
} }
private: int Foo::my_magic(int a, int b) {
int my_magic(int a, int b); }
};
value_ += result;
return result;
~/myprog/main.cpp }
int main() { }
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

7. use a consistent naming convention, camelCase or under_score

public:
} }
private: int Foo::myMagic(int a, int b) {
int myMagic(int a, int b); }
};
int result = myMagic(value_, number);
value_ += result;
return result;
~/myprog/main.cpp }
int main() { }
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

8. do not prefix queries and modifiers with get/set

public:
} }
};
value_ += result;
return result;
~/myprog/main.cpp }
int main() { }
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

8. do not prefix queries and modifiers with get/set

public:
int value() { namespace bar {
} }
};
value_ += result;
return result;
~/myprog/main.cpp }
int main() { }
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

9. do not import namespaces

public:
int value() { namespace bar {
} }
};
value_ += result;
return result;
~/myprog/main.cpp }
int main() { }
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

9. do not import namespaces

public:
explicit Foo(int seed); namespace bar {
int calc(int number = 7); Foo::Foo(int seed) : value_(seed) {
int value() { }
return value_;
} int Foo::myMagic(int a, int b) {
void print(char* prefix); return a + b - 3 + 8 - 5;
private: }
int value_;
int myMagic(int a, int b); int Foo::calc(int number) {
}; int result = myMagic(value_, number);
} value_ += result;
return result;
}

~/myprog/main.cpp void Foo::print(char *prefix) {
std::cout << prefix << value_ << "n";
#include "foo.hpp" }
}
int main() {
bar::Foo foo(2);
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

10. query functions should be declared const

public:
int value() { }
return value_;
void print(char* prefix); return a + b - 3 + 8 - 5;
private: }
int value_;
} value_ += result;
return result;
}

~/myprog/main.cpp void Foo::print(char *prefix) {
}
int main() {
bar::Foo foo(2);
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

10. query functions should be declared const

public:
int value() const { }
return value_;
void print(char* prefix) const; return a + b - 3 + 8 - 5;
private: }
int value_;
} value_ += result;
return result;
}

~/myprog/main.cpp void Foo::print(char *prefix) const {
}
int main() {
bar::Foo foo(2);
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

11. non-const functions are modifiers

public:

?
return value_;
private: }
int value_;
} value_ += result;
return result;
}

}
int main() {
bar::Foo foo(2);
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

12. prefer free-standing functions

public:
return value_;
private: }
int value_;
} value_ += result;
return result;
}

}
int main() {
bar::Foo foo(2);
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

12. prefer free-standing functions

public:
return value_;
} int myMagic(int a, int b) {
private: }
int value_;
}; int Foo::calc(int number) {
} int result = myMagic(value_, number);
value_ += result;
return result;
}

}
int main() {
bar::Foo foo(2);
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

13. use anonymous namespaces for private free-standing functions

public:
return value_;
} int myMagic(int a, int b) {
private: }
int value_;
}; int Foo::calc(int number) {
value_ += result;
return result;
}

}
int main() {
bar::Foo foo(2);
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

13. use anonymous namespaces for private free-standing functions

public:
explicit Foo(int seed); namespace {
int calc(int number = 7); int myMagic(int a, int b) {
int value() const { return a + b - 3 + 8 - 5;
return value_; }
} }
void print(char* prefix) const;
private: namespace bar {
int value_; Foo::Foo(int seed) : value_(seed) {
}; }
}
value_ += result;
return result;
~/myprog/main.cpp }
#include "foo.hpp" void Foo::print(char *prefix) const {
int main() { }
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

14. do not inline stuff in the class definition

public:
int value() const { return a + b - 3 + 8 - 5;
return value_; }
} }
void print(char* prefix) const;
private: namespace bar {
int value_; Foo::Foo(int seed) : value_(seed) {
}; }
}
value_ += result;
return result;
~/myprog/main.cpp }
int main() { }
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

14. do not inline stuff in the class definition

public:
int value() const; return a + b - 3 + 8 - 5;
void print(char* prefix) const; }
private: }
int value_;
}; namespace bar {
Foo::Foo(int seed) : value_(seed) {
inline int Foo::value() const { }
return value_;
value_ += result;
return result;
~/myprog/main.cpp }
int main() { }
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

15. by default keep your stuff in the implementation file

public:
private: }
int value_;
}; namespace bar {
Foo::Foo(int seed) : value_(seed) {
inline int Foo::value() const { }
return value_;
value_ += result;
return result;
~/myprog/main.cpp }
int main() { }
bar::Foo foo(2); }
for(int i=0; i<4; i++) {
foo.calc(i);
}
foo.print(prefix);
return 0;
}

15. by default keep your stuff in the implementation file

public:
private: }
int value_;
}; namespace bar {
} Foo::Foo(int seed) : value_(seed) {
}

value_ += result;
return result;
~/myprog/main.cpp }
#include "foo.hpp" int Foo::value() const {
return value_;
int main() { }
bar::Foo foo(2);
char * prefix = "the answer="; void Foo::print(char *prefix) const {
for(int i=0; i<4; i++) { std::cout << prefix << value_ << "n";
foo.calc(i); }
} }
foo.print(prefix);
return 0;
}

16. avoid member functions that both modifies and queries

public:
private: }
int value_;
}; namespace bar {
}

value_ += result;
return result;
~/myprog/main.cpp }
#include "foo.hpp" int Foo::value() const {
return value_;
int main() { }
bar::Foo foo(2);
char * prefix = "the answer="; void Foo::print(char *prefix) const {
for(int i=0; i<4; i++) { std::cout << prefix << value_ << "n";
foo.calc(i); }
} }
foo.print(prefix);
return 0;
}

16. avoid member functions that both modifies and queries

public:
void calc(int number = 7); int myMagic(int a, int b) {
private: }
int value_;
}; namespace bar {
}

void Foo::calc(int number) {
value_ += myMagic(value_, number);
}

~/myprog/main.cpp int Foo::value() const {
return value_;
int main() { void Foo::print(char *prefix) const {
bar::Foo foo(2); std::cout << prefix << value_ << "n";
for(int i=0; i<4; i++) { }
foo.calc(i);
}
foo.print(prefix);
return 0;
}

17. default arguments are depreciated, use delegation if you must

public:
void calc(int number = 7); int myMagic(int a, int b) {
private: }
int value_;
}; namespace bar {
}

}

return value_;
for(int i=0; i<4; i++) { }
foo.calc(i);
}
foo.print(prefix);
return 0;
}

17. default arguments are depreciated, use delegation if you must

public:
void calc(int number); int myMagic(int a, int b) {
private: }
int value_;
}; namespace bar {
}

}

return value_;
for(int i=0; i<4; i++) { }
foo.calc(i);
}
foo.print(prefix);
return 0;
}

18. the K&R vs BS war is over, use an extra space around & and *

public:
private: }
int value_;
}; namespace bar {
}

}

return value_;
for(int i=0; i<4; i++) { }
foo.calc(i);
}
foo.print(prefix);
return 0;
}

18. the K&R vs BS war is over, use an extra space around & and *

public:
void print(char * prefix) const; }
private: }
int value_;
}; namespace bar {
}

}

return value_;
int main() { void Foo::print(char * prefix) const {
for(int i=0; i<4; i++) { }
foo.calc(i);
}
foo.print(prefix);
return 0;
}

19. by not specifying const you say that something will change

public:
void print(char * prefix) const; }
private: }
int value_;
}; namespace bar {
}

}

return value_;
int main() { void Foo::print(char * prefix) const {
for(int i=0; i<4; i++) { }
foo.calc(i);
}
foo.print(prefix);
return 0;
}

19. by not specifying const you say that something will change

public:
void print(const char * prefix) const; }
private: }
int value_;
}; namespace bar {
}

}

return value_;
int main() { void Foo::print(const char * prefix) const {
const char * prefix = "the answer="; }
for(int i=0; i<4; i++) { }
foo.calc(i);
}
foo.print(prefix);
return 0;
}

20. reduce scope of variables

public:
private: }
int value_;
}; namespace bar {
}

}

return value_;
for(int i=0; i<4; i++) { }
foo.calc(i);
}
foo.print(prefix);
return 0;
}

20. reduce scope of variables

public:
private: }
int value_;
}; namespace bar {
}

}

return value_;
for(int i=0; i<4; i++) { }
foo.calc(i); }
}
const char * prefix = "the answer=";
foo.print(prefix);
return 0;
}

21. for-loops in C++ are often not written like this

public:
private: }
int value_;
}; namespace bar {
}

}

return value_;
for(int i=0; i<4; i++) { }
foo.calc(i); }
}
foo.print(prefix);
return 0;
}

21. for-loops in C++ are often not written like this

public:
private: }
int value_;
}; namespace bar {
}

}

return value_;
for (int i = 0; i != 4; ++i) { }
foo.calc(i); }
}
foo.print(prefix);
return 0;
}

22. in C++ you do not need to explicitly return from main

public:
private: }
int value_;
}; namespace bar {
}

}

return value_;
for (int i = 0; i != 4; ++i) { }
foo.calc(i); }
}
foo.print(prefix);
return 0;
}

22. in C++ you do not need to explicitly return from main

public:
private: }
int value_;
}; namespace bar {
}

}

return value_;
for (int i = 0; i != 4; ++i) { }
foo.calc(i); }
}
foo.print(prefix);
}

23. inject side-effects if you must have them

public:
private: }
int value_;
}; namespace bar {
}

}

return value_;
for (int i = 0; i != 4; ++i) { }
foo.calc(i); }
}
foo.print(prefix);
}

23. inject side-effects if you must have them

namespace bar { #include <ostream>
public:
void print(std::ostream & out, }
const char * prefix) const; }
private:
int value_; namespace bar {
}; Foo::Foo(int seed) : value_(seed) {
} }

}

return value_;
#include <iostream> }
#include "foo.hpp"
void Foo::print(std::ostream & out,
int main() { const char * prefix) const {
bar::Foo foo(2); out << prefix << value_ << "n";
for (int i = 0; i != 4; ++i) { }
foo.calc(i); }
}
foo.print(std::cout, prefix);
}

24. make sure headers compile by itself

namespace bar { #include <ostream>
public:
const char * prefix) const; }
private:
} }

}

return value_;
#include "foo.hpp"
for (int i = 0; i != 4; ++i) { }
foo.calc(i); }
}
}

24. make sure headers compile by itself

#include <iostream> #include <ostream>
#include "foo.hpp"
namespace bar {
class Foo { namespace {
public: int myMagic(int a, int b) {
explicit Foo(int seed); return a + b - 3 + 8 - 5;
void calc(int number); }
int value() const; }
void print(std::ostream & out,
const char * prefix) const; namespace bar {
private: Foo::Foo(int seed) : value_(seed) {
int value_; }
};
} void Foo::calc(int number) {
}

return value_;
#include "foo.hpp"
for (int i = 0; i != 4; ++i) { }
foo.calc(i); }
}
}

25. include your own header file first, standard libraries last

#include <iostream> #include <ostream>
#include "foo.hpp"
namespace bar {
int value_; }
};
}

return value_;
#include "foo.hpp"
for (int i = 0; i != 4; ++i) { }
foo.calc(i); }
}
}

25. include your own header file first, standard libraries last

#include <iostream> #include "foo.hpp"
#include <ostream>
namespace bar {
int value_; }
};
}

return value_;
#include <iostream>
for (int i = 0; i != 4; ++i) { }
foo.calc(i); }
}
}

26. prefer forward declarations in header files

#include <iostream> #include "foo.hpp"
#include <ostream>
namespace bar {
int value_; }
};
}

return value_;
#include <iostream>
for (int i = 0; i != 4; ++i) { }
foo.calc(i); }
}
}

26. prefer forward declarations in header files

#include <iosfwd> #include "foo.hpp"
#include <ostream>
namespace bar {
int value_; }
};
}

return value_;
#include <iostream>
for (int i = 0; i != 4; ++i) { }
foo.calc(i); }
}
}

27. don't need braces here

#include <ostream>
namespace bar {
int value_; }
};
}

return value_;
#include <iostream>
for (int i = 0; i != 4; ++i) { }
foo.calc(i); }
}
}

27. don't need braces here

#include <ostream>
namespace bar {
int value_; }
};
}

return value_;
#include <iostream>
for (int i = 0; i != 4; ++i) }
foo.calc(i); }
}

28. avoid side-effects if you can, prefer free-standing functions

#include <ostream>
namespace bar {
int value_; }
};
}

return value_;
#include <iostream>
for (int i = 0; i != 4; ++i) }
foo.calc(i); }
}

28. avoid side-effects if you can, prefer free-standing functions

#include <ostream>
namespace bar {
private:
const char * prefix,
const Foo & foo); void Foo::calc(int number) {
} value_ += myMagic(value_, number);
}

return value_;
#include <iostream>
int main() { const char * prefix,
bar::Foo foo(2); const Foo & foo) {
for (int i = 0; i != 4; ++i) out << prefix << foo.value() << "n";
foo.calc(i); }
print(std::cout, prefix, foo);
}

29. do not open a namespace when implementing free-standing functions

#include <ostream>
namespace bar {
private:
}

return value_;
#include <iostream>
int main() { const char * prefix,
bar::Foo foo(2); const Foo & foo) {
for (int i = 0; i != 4; ++i) out << prefix << foo.value() << "n";
foo.calc(i); }
}

29. do not open a namespace when implementing free-standing functions

#include <ostream>
namespace bar {
private:
}

return value_;
int main() { void bar::print(std::ostream & out,
bar::Foo foo(2); const char * prefix,
for (int i = 0; i != 4; ++i) const bar::Foo & foo) {
foo.calc(i); out << prefix << foo.value() << "n";
}

30. operator overloading is sometimes a nice thing

#include <ostream>
namespace bar {
private:
}

return value_;
int main() { void bar::print(std::ostream & out,
bar::Foo foo(2); const char * prefix,
for (int i = 0; i != 4; ++i) const bar::Foo & foo) {
foo.calc(i); out << prefix << foo.value() << "n";
}

C++ idioms by example (Nov 2008)

C++ idioms by example (Nov 2008)

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to C++ idioms by example (Nov 2008)

Similar to C++ idioms by example (Nov 2008) (20)

Recently uploaded

Recently uploaded (20)

C++ idioms by example (Nov 2008)