Template program sum of linked list values - templates

Question

I have the below code which i am planning to use it for sum or node values of a list.
#include <iostream>
#include <string>
using namespace std;
template <typename T, typename U, T node>
struct Sum {
static const U sum = Sum<T,U,node->next>::sum + node->value;
};
template <typename T,typename U, NULL>
struct Sum {
static const U sum = {};
};
template <typename T>
struct Node {
T value;
Node* next;
Node() {
value = {};
next = NULL;
}
};
int main()
{
Node<string>* n1;
n1->value = "Hello";
Node<string>* n2;
n2->value = "World!";
n1->next = n2;
const Node<string>* const nx=static_cast<const Node<string>* const>(n1);
const string str=Sum<Node<string>*, string, nx>::sum;
return 0;
}
I get the below errors.
1>templatemetaprogramming.cpp(15):
error C2059: syntax error: 'constant'
1>templatemetaprogramming.cpp(18):
error C2976: 'Sum': too few template arguments 1>
1>templatemetaprogramming.cpp(16):
note: see declaration of 'Sum'
First one i think is because i cannot use NULL as constant to Node*
second one seems to be the same, i did cast to a constant the Node pointer. Can anyone help to fix it? Thank you

Answer 1

You try to compute something at compile time which is only available at runtime. In fact this is the whole point of a linked list (it is a dynamic data structure which is unknown before running the program). So the computation of it's sum definetly has to happen at compile time.
Templates are evaluated at compile time. Therefore you can only pass constant expressions to a template but no expressions that will only be known at runtime.
I am quite sure you added all the const and static_cast keywords in the following piece of code, because the compiler complained about being unable to use non-const expressions in that context or something similar:
const Node<string>* const nx=static_cast<const Node<string>* const>(n1);
const string str=Sum<Node<string>*, string, nx>::sum;
If you look at it, semantically this just doesn't make any sense. Let's say you wrote this originally (just to remove some complexity):
Node<string>* nx = new Node<string>(n1);
string str = Sum<Node<string>*, string, nx>::sum;
What will this evaluate to? Let's play preprocessor for a while (Sure a compiler is much smarter, but I am not):
The first expression will instantiate an object of the following type
struct Node {
string* value;
Node* next;
Node() {
value = {};
next = NULL;
}
};
The second line something like:
struct Sum {
static const string sum = Sum<Node<string>*, string, nx->next>::sum + nx->value;
};
What is nx in that context? This doesn't make sense, right? Again, this is not what the compiler does, but you hopefully get the idea.
I edited your code to do what you (probably) want. (Working example here)
#include <iostream>
#include <string>
using namespace std;
template <typename T>
struct Node {
T value;
Node* next;
Node() {
value = T();
next = NULL;
}
static T sum(Node<T> *node) {
T s;
Node<T> *next = node;
while(next != NULL) {
s = s + next->value;
next = next->next;
}
return s;
}
};
int main()
{
Node<string> n1 = Node<string>();
n1.value = string("Hello");
Node<string> n2 = Node<string>();
n2.value = string("World!");
n1.next = &n2;
string str = Node<string>::sum(&n1);
cout << str << endl;
return 0;
}
Note:
Besides from the things I mentioned above your code has many other issues. This for example
Node<string>* n1;
n1->value = "Hello";
will lead to undefined behavior and most likely to a segmentation fault as the content of n1 is not defined. I don't know your c++ knowledge but I think you should learn about pointers, stack, heap and so on before learining anything about templates.

Answer 2

What you want to achieve is impossible, you can not mix compilation time computation and runtime execution: in your case, linked list is created at runtime. But your template instantiation is done at compilation time: compiler is not able to predict how many template it has to create to run through complete list.
What you want to do has to be done with standard function, not with template. You only can use template for static data, like type, but definitively not for runtime variable. Runtime variable should be pass as a function parameter. So, you can have a function like this:
template <typename T, typename U>
U Sum(T *node)
{
// run through complete list by iteration or recursion to do sum
}
You can achieve what you want by a lot of different possible designs. Just take care that runtime data is passed as function parameter.
If you want to iterate over static data, you can use variadic template.
And in C++11 std::string is always a runtime data, it can not be used as a constant expression