How do I define a static member of a partial specialisation? - c++

Question

As pointed out in the comments, my problem is actually:
template <typename T, typename U>
struct X {
static int i;
};
template <typename U>
int X<int, U>::i = 42;
with compiler error:
error: template definition of non-template 'int X<int, U>::i'
7 | int X<int, U>::i = 42;
How can I define this static member?
Original question below.
My use case is maybe a little odd:
#include <string>
#include <map>
#include <functional>
#include <memory>
template<typename ResourceType,
typename AllocatorType>
class ResourceManager
{
public:
typedef std::string IDType;
typedef std::shared_ptr<ResourceType> ResourceHandle;
typedef std::function<ResourceType(const IDType&, AllocatorType)> LoadFunc;
static ResourceHandle GetResource(const IDType& id, AllocatorType& alloc)
{
auto itr = m_resources.find(id);
if(itr != m_resources.end())
return itr->second;
ResourceHandle r
= std::make_shared<ResourceType>(m_loadFunc(id, alloc));
m_resources[id] = r;
return r;
}
static std::map<IDType, ResourceHandle> m_resources;
static LoadFunc m_loadFunc;
};
struct PretendAllocator
{
};
struct SomeResource
{
int i;
};
template<typename Allocator>
SomeResource load_some_resouce_from_file(const std::string& filename,
Allocator& alloc)
{
SomeResource x;
x.i = 12;
// let's pretend that the allocator was used and the filename was used
return x;
}
template<typename Allocator>
using SomeResourceManager = ResourceManager<SomeResource, Allocator>;
template<typename Allocator>
typename SomeResourceManager<Allocator>::LoadFunc
SomeResourceManager<Allocator>::m_loadFunc
= [](const SomeResourceManager<Allocator>::IDType& id,
Allocator& alloc)
{
return load_some_resouce_from_file(id, alloc);
}
int main()
{
// I don't know what kind of allocator I may have in real-world
PretendAllocator pretendAllocator;
// But I would use it to allocate a resource managed through Manager
SomeResourceManager<PretendAllocator>::ResourceHandle resource
= SomeResourceManager<PretendAllocator>::GetResource("some file",
pretendAllocator);
return 0;
}
This throws a bunch of compiler errors.
main.cpp|61|error: template definition of non-template 'typename ResourceManager<SomeResource, Allocator>::LoadFunc ResourceManager<SomeResource, Allocator>::m_loadFunc'|
main.cpp|62|error: invalid use of incomplete type 'SomeResourceManager<Allocator>'|
main.cpp|8|note: declaration of 'SomeResourceManager<Allocator>'|
main.cpp|68|error: expected ',' or '...' before 'int'|
main.cpp|77|error: expected ')' at end of input|
main.cpp|62|note: to match this '('|
main.cpp|77|error: expected '{' at end of input|
My use case is that I would have multiple resources which are expensive to load/acquire. So the ResourceManager has some code around it that will only call the static std::function members when absolutely required (real-world is more complex than this example).
The above seemed like the best way to do this. Basically, when defining a Resource, you would also create an alias for a ResourceManager<YourResource> but I now have the added complexity of needing to include an Allocator.
How can I get the above to compile? I'm not sure exactly what the problem is. If it's not possible, would be great to hear an alternative.

Answer 1

You cannot partially specialise a member without partially specialising the entire class.
Insert a partial specialisation
template <typename U>
struct X<int, U> {
static int i;
};
before the definition of i and it should work.