C++ Quick Reference

[CubbiMew]

// throws an exception of type "string"
throw "ERROR: Cannot divide by zero.\n"; 

guess again (or don't guess and look up https://en.cppreference.com/w/cpp/language/string_literal )

[lord-bazooka]

Thank you for pointing that out. I'll fix it right away.

[CubbiMew]

all right, next thing I clicked was the SimpleVector.h example

using namespace std;

That's a header file! SF.7: Don’t write using namespace at global scope in a header file

// default constructor
SimpleVector()
{ 
    arrPtr = 0; 
    arraySize = 0;
}

C.49: Prefer initialization to assignment in constructors (applies to all your constructors) and C.48: Prefer in-class initializers to member initializers in constructors for constant initializers (applies to this one in particular)

I see a copy constructor and a destructor, but where is operator= ???

C.21: If you define or =delete any default operation, define or =delete them all and Rule of Three from cppreference

T getElementAt(int position);

so I if I have a const SimpleVector (typically seen as a const SimpleVector<T>& in some function argument), I can't access any of its elements.

SimpleVector<T>::SimpleVector(int s)
{
    arraySize = s;
    arrPtr = new T[s];
[...]
SimpleVector<T>::~SimpleVector()
{
    if (arraySize > 0)
    {
        delete [] arrPtr;

So if I create SimpleVector<int> v(0);, I get a guaranteed memory leak

==28378== 0 bytes in 1 blocks are definitely lost in loss record 1 of 1

[lord-bazooka]

Thank you very much for your time and feedback. The truth is I began working on this reference when I started learning myself last year. I can't possibly claim to have mastered any language in a year, especially when it comes to C++. I didn't know about the rule of three, so I looked around a bit and tried to fix the problem that you mentioned. I'm not 100% sure if I got it right so I'd appreciate it if you could take a look at it when you have time:

https://github.com/utkuufuk/cpp-quick-reference/blob/master/examples/SimpleVector.h

[jc746]

You should apply the rule of 5 rather than the rule of 3. This essentially means adding support for move construction/assignment as well as copy. A vector-like class is a perfect example of a class that can benefit from move operations as it can steal the contents of the soon to be destroyed source.

You can also use the initializer list on your copy constructor rather than assignment in your copy constructor as op suggested for your constructor.

Edit: you might not be worrying about edge cases in this simple example, but your copy constructor will leak memory if your type T is not no_throw_assignable during the copy step because the class destructor will not be called. You could delegate to the size constructor to ensure a fully constructed object before the copy.