My programming foundations were formed in Java, but I've decided to only use C++ from now on for my projects as a personal learning experience. Static utility classes are common in Java; but I don't think they work the same as in C++. I'd like the following:

* Code review of the functions to determine potential function-specific improvements
* Analysis of the general architecture/structure to determine if static methods are the way to go. 
If they are not, what would one recommend to achieve the desired result (which is to have a globally accessible set of utility methods)?

Here's the code:

util.h
------

```cpp
#ifndef STDAFX_INCLUDE
#define STDAFX_INCLUDE

#include "stdafx.h"

#endif

#include <sstream>
#include <algorithm> 
#include <functional> 
#include <cctype>
#include <locale>
#include <random>

// Utility class to manage misc. functions

class Util {
public:
    static std::string serialize_http_args(std::map<std::string, std::string>);
    static std::string serialize_http_headers(std::map<std::string, std::string>);
    static int randrange(int min, int max);
    static void trim(std::string&);
    static void ltrim(std::string&);
    static void rtrim(std::string&);
    static std::string trim_copy(std::string);
    static std::string ltrim_copy(std::string);
    static std::string rtrim_copy(std::string);
    static std::string int2str(int);
    static std::string lowercase(std::string);
    static std::vector<std::string> split(std::string, std::string);
    static std::vector<std::string> split_once(std::string, std::string);
};

```

util.c
------

```
#include "util.h"

// returns a random number in range min through max, inclusive.
int Util::randrange(int min, int max) {
    std::random_device rd; // obtain a random number from hardware
    std::mt19937 eng(rd()); // seed the generator
    std::uniform_int_distribution<> distr(min, max); // define the range
    return distr(eng);
}

// takes a map of arguments and converts it to a string representation
std::string Util::serialize_http_args(std::map<std::string, std::string> _args) {
    if (_args.size() > 0) {
        size_t counter = 1;
        std::string args_str = "";
        for (auto const& arg : _args) {
            args_str += arg.first + "=" + arg.second;
            if (counter < _args.size())
                args_str += "&";
            counter++;
        }
        return args_str;
    }

    return "";
}

// takes a map of headers and converts it to the string representation
std::string Util::serialize_http_headers(std::map<std::string, std::string> _headers) {
    if (_headers.size() > 0) {
        std::string headers_ser = "";
        for (auto const& header : _headers)
            headers_ser += header.first + ": " + header.second + "\r\n";
        return (headers_ser + "\r\n");
    }

    return "";
}

// splits a string infinitely by delimiter until completely tokenized
std::vector<std::string> Util::split(std::string s, std::string delimiter) {
    std::vector<std::string> output;

    std::string::size_type prev_pos = 0, pos = 0;

    while ((pos = s.find(delimiter, pos)) != std::string::npos)
    {
        std::string substring(s.substr(prev_pos, pos - prev_pos));
        output.push_back(substring);
        prev_pos = ++pos;
    }

    output.push_back(s.substr(prev_pos, pos - prev_pos)); // Last word

    return output;
}

// splits a string by the first instance of delimiter
std::vector<std::string> Util::split_once(std::string s, std::string delimiter)
{
    std::vector<std::string> output;
    std::string::size_type pos = 0;

    if ((pos = s.find(delimiter, pos)) != std::string::npos) {
        output.push_back(std::string(s.substr(0, pos)));
        output.push_back(std::string(s.substr(pos + 1)));
    }

    return output;
}

// trim from start (in place)
void Util::ltrim(std::string & s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(),
        std::not1(std::ptr_fun<int, int>(std::isspace))));
}

// trim from end (in place)
void Util::rtrim(std::string & s) {
    s.erase(std::find_if(s.rbegin(), s.rend(),
        std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
}

// trim from both ends (in place)
void Util::trim(std::string & s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
std::string Util::ltrim_copy(std::string _s) {
    std::string s = _s;
    ltrim(s);
    return s;
}

// trim from end (copying)
std::string Util::rtrim_copy(std::string _s) {
    std::string s = _s;
    rtrim(s);
    return s;
}

// trim from both ends (copying)
std::string Util::trim_copy(std::string _s) {
    std::string s = _s;
    trim(s);
    return s;
}

// convert string to lowercase version of same string
std::string Util::lowercase(std::string _s) {
    std::string s = _s;
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    return s;
}

//convert type integer to string
std::string Util::int2str(int i) {
    std::string out;
    std::stringstream ss;
    ss << i;
    return ss.str();
}

```

```