Large-scale difficulty with namespaces, function templates, and static data

Question

This scope issue seems like a type of C ++ fix that Scott Meyers would consider in one of his effective C ++ books.

I have a function Analyzethat does some analysis over a range of data. The function is called from several places with different types of iterators, so I made it a template (and thus implemented it in the header file). The function depends on a static data table AnalysisTable, which I do not want to show the rest of the code.

My first approach was to make table a static constinside Analysis.

namespace MyNamespace {

  template <typename InputIterator>
  int Analyze(InputIterator begin, InputIterator end) {
    static const int AnalysisTable[] = { /* data */ };
    ... // implementation uses AnalysisTable
    return result;
  }

}  // namespace MyNamespace

, AnalysisTable Analyze, (, , ).

, :

namespace MyNamespace {

  const int AnalysisTable[] = { /* data */ };

  template <typename InputIterator>
  int Analyze(InputIterator begin, InputIterator end) {
    ... // implementation uses AnalysisTable
    return result;
  }

}  // namespace MyNamespace

, . , :

namespace MyNamespace {

  namespace {  // unnamed to hide AnalysisTable
    const int AnalysisTable[] = { /* data */ };
  }  // unnamed namespace

  template <typename InputIterator>
  int Analyze(InputIterator begin, InputIterator end) {
    ... // implementation uses AnalysisTable
    return result;
  }

}  // namespace MyNamespace

, , , . Analyze , . , , , .

, extern Analyze.

// foo.h ------
namespace MyNamespace {

  template <typename InputIterator>
  int Analyze(InputIterator begin, InputIterator end) {
    extern const int AnalysisTable[];
    ... // implementation uses AnalysisTable
    return result;
  }

}  // namespace MyNamespace

// foo.cpp ------
#include "foo.h"
namespace MyNamespace {
    const int AnalysisTable[] = { /* data */ };
}

, , , , . , , " AnalysisTable". ! ( - , ?)

, , , :

// foo.h -----
namespace MyNamespace {

  namespace PrivateStuff {
    extern const int AnalysisTable[];
  }  // unnamed namespace

  template <typename InputIterator>
  int Analyze(InputIterator begin, InputIterator end) {
    ... // implementation uses PrivateStuff::AnalysisTable
    return result;
  }

}  // namespace MyNamespace

// foo.cpp -----
#include "foo.h"
namespace MyNamespace {
  namespace PrivateStuff {
    const int AnalysisTable[] = { /* data */ };
  }
}

AnalysisTable (yay!), (boo!). , , .

, Analyze?

Answer 1

, , , , .

class AnalysisTable
{
    static const int data[];

    template <typename InputIterator>
    friend int Analyze(InputIterator begin, InputIterator end);
};

template <typename InputIterator>
int Analyze(InputIterator begin, InputIterator end)
{
    // ...
    x = AnalysisTable::data[n];
    // ...
}