Thread: including namespaces

This is just for fun, it is not in any way an attempt to say that using std::count is bad. But there are still the same types of errors that could occur - name conflicts or unknowingly using the wrong name. Here is my contrived example.

Code:

// In MyClass.h
#ifndef MYCLASS_H_
#define MYCLASS_H_

#include <iostream>
using std::cout;
using std::endl;
#include <algorithm>
using std::count;

class MyClass
{
public:
    MyClass() {
        sizeOfA = 8;
        A = new int[sizeOfA];
        for (int i=0; i<sizeOfA; i++)
            A[i] = (i%3)+1;
    }
    void PrintItemCount(int item) {
        cout << item << " count: " << count(A, A + sizeOfA, item) << endl;
    }
private:
    int* A;
    int sizeOfA;
};
#endif // MYCLASS_H_

Code:

// In HelperFunc.h
#ifndef HELPER_FUNC_H_
#define HELPER_FUNC_H_
int count(int* array1, int* array2, int numElements)
{
    int sum = 0;
    for (int i = 0; i < numElements; i++)
    {
        sum += array1[i];
        sum += array2[i];
    }
    return sum;
}
#endif // HELPER_FUNC_H_

Code:

// In main.cpp

// Maybe this header is included by another header deep in a library somewhere.
#include "MyClass.h"

// Oops! Forgot to #include "HelperFunc.h"

#include <iostream>
using std::cout;
using std::endl;

int main()
{
    int array1[] = { 2, 0, 4, 6, 2, 3, 2, -7 };
    int array2[] = { 5, 8, 0, 4, 1, 1, -4, 2 };
    // Try to use the count in HelperFunc.h
    cout << count(array1, array2, 8) << endl;
}

Result: undefined behavior - on my machine it crashed. Since HelperFunc.h wasn't included, the code found the std::count included in the MyClass.h header file. Because the using std::count was put in that header file, the main code used the algorithm count instead of the intended one.

This is more of an indictment on putting using directives in header files, but there you go.

Nice example jlou... You saved me from having to think later on.

And, the problem may just throw a compile-time error, or crash, and not be a subtle little bug, but it is nice to be able to reuse those names for your own functions/objects on occasion.

Of course it exists Sang-drax, but at some point it crosses over into the realm of "that would never happen - I'm not stupid enough to ever do that." I think bringing in a single name from a namespace is perfectly acceptable, preferably inside the scope of a function or loop where it is being used. Bringing in a single name from a namespace at the top of a source file can also be acceptable in my personal opinion, but I don't think it would necessary in most cases, especially for the std namespace.

So, here is my example of a using directive in a source file that only brings in a single name and causes unwanted behavior.

Code:

// In HelperFunc.h
#ifndef HELPER_FUNC_H_
#define HELPER_FUNC_H_
int count(int* array1, int* array2, int numElements)
{
    int sum = 0;
    for (int i = 0; i < numElements; i++)
    {
        sum += array1[i];
        sum += array2[i];
    }
    return sum;
}
#endif // HELPER_FUNC_H_

Code:

// In main.cpp
// Oops! Forgot to #include "HelperFunc.h"

// In main.cpp
#include <iostream>
#include <algorithm>

int main()
{
    int array1[] = { 2, 0, 4, 6, 2, 3, 2, -7 };
    int array2[] = { 5, 8, 0, 4, 1, 1, -4, 2 };

    using std::cout;
    using std::endl;
    using std::count;

    // Use std::count
    cout << count(array1, array1 + sizeof(array1), 2) << endl;

    // ...

    // Try to use the count in HelperFunc.h
    cout << count(array1, array2, 8) << endl;
}

Result: undefined behavior. On my machine it crashes.

Really? Well, I guess the using directive is more dangerous than I thought.