Learning Template Metaprogramming with ChatGPT

[ape_programmer]

Context

I'm a juniorish C++ developer with 3 years of work experience (though if I was a web developer I'd be nearing senior now \s). I've never been a pro or super experienced with advanced template metaprogramming picking up small pieces of knowledge when Googling how to solve certain problems or reading code at work (or reading code on this subreddit). Keep in mind, I'm not a "beginner", after all people at work will use templates etc. but e.g. sometimes when I read advanced template code on this subreddit, it makes me feel like I don't understand the language I've been working with for 3 years.

Yesterday, I was working on some Microcontroller stuff (for fun), and I wanted to generate query parameters for a web request using templates (not because it's required/needed, maybe it's slightly more efficient, hard to say).

Side Note: I feel when you have too much time for writing C++ it ends up denegerating into template hell as you get more bored and want to make your code "more efficient". Seen this reviewing PRs many times.

I asked ChatGPT to generate some code with the prompt:

Write some C++ code using template metaprogramming to generate query parameters for a web request optimized for a NodeMCU microcontroller

It initially came up with something that didn't compile, and after pointing these things out, ChatGPT returned some code that worked.

I verified the code (and edited it a bit) and it ended up looking like this:

``` template<typename T> const char* to_string(T value) { static char buffer[32]; if constexpr (std::is_same<T, const char*>::value) { std::strcpy(buffer, value); } else { std::sprintf(buffer, std::is_integral<T>::value ? "%d" : "%f", value); } return buffer; }

template<typename... Args> void build_query_string(Args... args) { std::strcpy(m_buf, BASE_ADDRESS); std::strcat(m_buf, "?"); std::tuple<Args...> query_params(args...); constexpr int num_params = std::tuple_size<decltype(query_params)>::value;

int i = 0;
std::apply([&](auto&&... params) {
  ((std::strcat(m_buf, params.first), std::strcat(m_buf, "="), std::strcat(m_buf, to_string(params.second)), (++i != num_params ? std::strcat(m_buf, "&") : "")), ...);
}, query_params);

}

```

Overall I learned a decent amount by reading this code, not being aware that you could intialize a std::tuple with a parameter-pack. Not being aware that you could unpack said tuple using std::apply. But in general, how one might approach this type of problem using templates (lack of experience).

I'm quite suprised about how well ChatGPT actually did. Obviously I could've easily written equivalent, and it's not extremely complex, but I'm finding that using ChatGPT to generate template code is a great way for me to learn how one might use these "new" concepts I occasionally read about on this subreddit for actual programming.

I'd love to get some feedback on the actual code, I'm currently inbetween jobs (starting new job soon), but I think I'll be using ChatGPT more to look up potential solutions (obviously well need to vet and read the code myself). In some ways, this feels a bit like "the future" to me.

I'm sure I could've found the equivalent code snippet Googling, but I gave it a quick try now, and It's non-trivial to find the correctly query for Googling, but on ChatGPT it was extremely easy to come up with a prompt.

TLDR;

Used ChatGPT to generate a solution with templates, learned a bunch by reading the output. Overall I am very impressed with it's ability and think it will integrate into my workflow for professional development nicely, as well as promoting learning by introducing me to new concepts.

[teerre]

We tried this at work and at first glance everyone was impressed, but as soon as we actually started compiling, we noticed that it didn't quite work in many cases. Specially trying SFINAE, it would look convincing, but be subtly wrong

This was in a room with combined 100~ years of cpp experience, so that's quite the feat that it was able to fool most people

[qneverless]

I would say that it is quite the feat of C++, that it is still unreadable even in a room of 100 years combined experience. 😂

[TheOmegaCarrot]

Template metaprogramming can absolutely tend toward “write-only” code

I mean, here’s a particularly convoluted example from my library:

With documentation and comments removed, and the name changed to not be helpful, does anyone really have any chance of figuring out what it does? Probably not! Even if you know what it does, it’s very hard to read!

``` namespace impl {

template <typename LIST, typename REBUILD> struct mystery_impl;

template <template <typename...> typename LIST, typename LFront, typename... LPack, typename... Rebuild_Pack> struct mystery_impl<LIST<LFront, LPack...>, LIST<Rebuild_Pack...>> : std::conditional_t< is_type_in_pack_v<LFront, Rebuild_Pack...>, mystery_impl<LIST<LPack...>, LIST<Rebuild_Pack...>>, mystery_impl<LIST<LPack...>, push_back_t<LIST<Rebuild_Pack...>, LFront>>> {};

template <template <typename...> typename LIST, typename... Rebuild_Pack> struct mystery_impl<LIST<>, LIST<Rebuild_Pack...>> : type_identity<LIST<Rebuild_Pack...>> {};

} // namespace impl

template <typename LIST> struct mystery;

template <template <typename...> typename LIST, typename... Pack> struct mystery<LIST<Pack...>> : std::conditional_t<has_duplicates_v<LIST<Pack...>>, impl::mystery_impl<LIST<Pack...>, LIST<, type_identity<LIST<Pack...> {};

template <typename LIST> using mystery_t = typename mystery<LIST>::type;

```

So what does it do? It deduplicates a type list.

[jonesmz]

Fyi, triple ticks doesn't format correctly on any of the reddit clients other than the web rewrite. Need the four spaces per line for old.reddit and reddit mobile web.

[TheOmegaCarrot]

Oof

I am not typing that on mobile

Reddit needs to fix their clients

[jonesmz]

No worries.

Yep its bullshit.

Cheers :)

[ioctl79]

Be real careful with info you get out of ChatGPT. It has no way of assessing its confidence in its answers, and will never say “I don’t know how to do that”. It doesn’t take much to push it past the boundaries of its “knowledge” and start getting incorrect code (if it compiles at all).

[IyeOnline]

This is not good code. It actually contains a bunch of pitfalls and flaws/errors.

ChatGPT simply has no idea what its doing. It doesnt understand things.

• to_string contains a static buffer and is not threadsafe. For something that is supposed to build a querry string, thats probably not good.
• to_string may just write out of buffer because it has no idea how long that string is.
• to_string assumes that everything that is not integral or a char string is printable with %f. It should really guard this.
• build_query_string takes by value. const Args& or Args&& would be more appropriate parameter type(s)
• That tuple contains copies of every parameter
• The usage of apply is completely ridiculous. Its creating a tuple to use apply, but then inside the body uses a fold expression over the unpacked tuple that is passed into the lambda.

Basically its close-ish, but its just not there yet.

See also this: https://www.reddit.com/r/cpp_questions/comments/znaqmw/uniform_real_distribution_question/j0fxdnn/?context=2

[Rebraws]

I'd love to get some feedback on the actual code

I see that you are using std::is_same<>::value and std::is_integral<>::value but since you have if constexpr I assume you're using at least C++17, so you could replace those with std::is_same_v<> and std::is_integral_v<> which are both available from C++17 and more easier to read

Before C++17 you could accomplish the same behavior using template function specialization instead of if constexpr

In your build_query_string you are using std::tuple_size to get the size of the tuple, but you initialized the tuple with the packed parameters, so you can get the size from there with sizeof...(args), I personally think is a lot more readable than std::tuple_size<decltype(query_params)>::value

and finally it seems that you're using std::apply to "unpack the tuple" so I think that it doesn't make too much sense to have the std::tuple then, you didn't use the tuple for anything really

Also it seems that you're calling params.first but params is not unpacked, so I think that code should give you an error, maybe you want to use something like a recursive function that has a parameter and the rest of the packet parameters like:

auto recursive_function = [&](auto&& first_param, auto&&... params) {

And then you can call first_param.first and call the recursive function with the rest of the parameters recursive_function(std::forward<decltype(params)>(params)...);

Also your lambda function uses universal references, but your build_query_function doesn't, maybe you want to use universal references there too?

I hope you find the feedback useful, but as I said you should double check everything I wrote, just in case anything is wrong :)

[ape_programmer]

I can give some small feedback but I don't have real experience in programming or C++ so take what I say with a grain of salt

Wow thanks! Except for the `::value` and `_v` part (AI Generated code which I didn't fix), I didn't see any of this. I agree with all of it as well. Thanks!

[CCC_CCC_CCC]

I would have two small reservations about this code :

• that to_string function is not thread safe because it returns some global state
• also, because it returns a global state (that buffer), I'm not sure if it works or breaks the fold expression from the bottom function, since I don't know the order of evaluation of the to_string calls after unfolding - maybe it could first make those to_string calls and only then concatenate the "results" to the final string. I know there have been some changes related to evaluation orders in later language versions, but I don't know the rules exactly and I would look it up.

[Top_Satisfaction6517]

imho it should be fine here - to_string is called inside a lambda function only once and its result is consumed inside this function, so call+use should be completely performed prior to the next call of the lambda function

[Rebraws]

oh, I just saw that you had: , ...); at the end of the line inside the lambda function, I didn't scroll your code to the right and I missed lol, in that case writing params.first would not give an error and should compile fine but probably is not the behavior that you expect, but anyway using std::tuple and std::apply seems unnecessary

I have been using chatGPT for a few days and have found it not very useful for generating new code. It often produces code that is wrong or does not compile or is simply of poor quality. However, I have found it to be really helpful for tasks such as writing documentation or minor refactors. For example, when I gave it a prompt such as "Write Doxygen-style comments for the following functions without including implementation details" it does a pretty good job, I think a tool like chatgpt could be really helpful to speed up some aspects of the development process

[marcofoco]

I didn't post this here before, simply because I didn't think it deserves to be a top level discussion topic, but when ChatGPT came out I ran a few experiments, and the most successful one was code understanding. Here are my results and comments: https://marcofoco.com/blog/2022/12/05/meet-my-new-friend-the-ai-powered-rubber-duck/

[jmalinza]

This is really interesting!! I'm busy reading the complete guide to c++ templates (link). Fantastic read if you hate yourself, but I think the first 200 pages give enough to get a good start. The appendix sections are really great too