Skip to content

Instantly share code, notes, and snippets.

@texus texus/toLower.cpp

Last active Dec 14, 2019
Embed
What would you like to do?
String to lowercase at compile time
// This file contains code on how to convert a string to lowercase at compile time.
// A large part of the imlementation was taken from http://stackoverflow.com/a/15912824/3161376 which solved the problems that I had in the old implementation.
// The string struct will hold our data
// The declaration of our string struct that will contain the character array
template<char... str>
struct string
{
// The characters are immediately converted to lowercase when they are put in the array
static constexpr const char chars[sizeof...(str)+1] = {((str >= 'A' && str <= 'Z') ? str + ('a' - 'A') : str)..., '\0'};
};
// The definition of the above array
template<char... str>
constexpr const char string<str...>::chars[sizeof...(str)+1];
// The apply_range exists so that we can create a structure Class<Indices...> where the amount of indices are based on a count value that is passed
template<unsigned count, // Amount of indices to still generate
template<unsigned...> class meta_functor, // The class to which we will apply the indices
unsigned... indices> // Indices that we generated so far
struct apply_range
{
typedef typename apply_range<count-1, meta_functor, count-1, indices...>::result result; // Add one index and recursively add the others
};
template<template<unsigned...> class meta_functor, // The class to which we will apply the indices
unsigned... indices> // The generated indices
struct apply_range<0, meta_functor, indices...>
{
typedef typename meta_functor<indices...>::result result; // Apply the indices to the passed class and get the string that it produced
};
// This is where all the things come together and the string is produced.
// The lambda_str_type is a struct containing the literal string.
// The produce struct is what will be given to apply_range to fill in the indices.
// When result which will be returned from apply_range is the one from here which is the lowercase char array.
template<typename lambda_str_type>
struct string_builder
{
template<unsigned... indices>
struct produce
{
typedef string<lambda_str_type{}.chars[indices]...> result;
};
};
// The way to call it in the code is too complex to be used directly in the code.
// Calling it from a function is also not possible because then the string is a parameter and not a compile time string literal.
// So we use a define to keep the code simple and still put that complex expression directly in the code
// Returning the const char* from this function will still happen at runtime, but the actual conversion to lowercase is fully done on compile time.
#define TOLOWER(string_literal) \
[]{ \
struct constexpr_string_type { const char * chars = string_literal; }; \
return apply_range<sizeof(string_literal)-1, string_builder<constexpr_string_type>::produce>::result::chars; \
}()
// The test code
#include <string>
int main()
{
// Checking performance of using this TOLOWER call (timings are for non-optimized build)
// 0.925s (empty loop that is not optimized away also needs time to execute, loops in the code below can't be faster than this one)
for (unsigned int i = 0; i < 500000000; ++i) {
}
// 1s (returning the const char* is done at runtime which is why this loop is slightly slower than an empty loop)
for (unsigned int i = 0; i < 500000000; ++i) {
const char* s = TOLOWER("HELLO");
}
// 7.4s (doing the conversion at runtime)
for (unsigned int i = 0; i < 500000000; ++i) {
char s[] = "HELLO";
for (unsigned int j = 0; j < 5; ++j)
s[j] = ((s[j] >= 'A' && s[j] <= 'Z') ? s[j] + ('a' - 'A') : s[j]);
}
// When using std::string
// 9s (most of the time is used for creating the std::string, conversion itself still happens at compile time)
for (unsigned int i = 0; i < 500000000; ++i) {
std::string s = TOLOWER("HELLO");
}
// 31s (doing the conversion at run runtime while using std::string)
for (unsigned int i = 0; i < 500000000; ++i) {
std::string s = "HELLO";
for (unsigned int j = 0; j < 5; ++j)
s[j] = ((s[j] >= 'A' && s[j] <= 'Z') ? s[j] + ('a' - 'A') : s[j]);
}
}
@AlexisWilke

This comment has been minimized.

Copy link

AlexisWilke commented May 9, 2019

Excellent, that works! The one thing I don't quite understand, though, is the static in the struct string. How come I can create any number of strings with one single such static? Is it because each time a new template is instantiated so each time a new static is created?

@texus

This comment has been minimized.

Copy link
Owner Author

texus commented Dec 14, 2019

I don't seem to get notifications from comments here. For those who wonder the same in the future: for each unique string a different type is instantiated and each type indeed have their own static member.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.