mktime will convert a struct tm into a Unix timestamp in seconds. Multiply by 1000 and add the extra milliseconds to the result.

Function time_t time(time_t* timer) returns the number of seconds elapsed since 00:00 hours, Jan 1, 1970 UTC. In addition, if the input argument timer != NULL, then the function also sets this argument to the same value (so you probably have no reason to call it with anything else but NULL).

Function struct tm* localtime(const time_t* timer) takes the number of seconds elapsed since 00:00 hours, Jan 1, 1970 UTC, and returns a structure that represents the equivalent time & date. If you're working on a multi-threaded application, then please note that this function is not thread safe.

As to your question - is there any way for converting milliseconds to time & date - yes, but:

• Take into consideration that the milliseconds will be considered as of 00:00 hours, Jan 1, 1970 UTC.
• Since the time_t type is 32-bit long, you will not be able to convert 4G*1000 milliseconds or more.

Here is a function for converting milliseconds to time & date:

struct tm* GetTimeAndDate(unsigned long long milliseconds)
{
    time_t seconds = (time_t)(milliseconds/1000);
    if ((unsigned long long)seconds*1000 == milliseconds)
        return localtime(&seconds);
    return NULL; // milliseconds >= 4G*1000
}

What about std::sscanf?

#include <iostream>
#include <cstring>

int main() {
    const char *str_time = "20160907-05:00:54.123";
    unsigned int year, month, day, hour, minute, second, miliseconds;

    if (std::sscanf(str_time, "%4u%2u%2u-%2u:%2u:%2u.%3u", &year, &month,
               &day, &hour, &minute, &second,&miliseconds) != 7)
    {
        std::cout << "Parse failed" << std::endl;
    } 
    else
    {
        std::cout << year << month << day << "-" << hour << ":" 
                  << minute << ":" << second << "." << miliseconds
                  << std::endl;
    }
}

Output (ideone): 201697-5:0:54.123.

However, you should make sure the input is valid (for example, day can be in the range of [0,99]).

You just need to use regular subtraction, then multiply by 86400000.

Date

(Date__c - DATE(1970, 1, 1)) * 86400000

DateTime

(Date_Time__c - DATETIMEVALUE("1970-01-01 00:00:00")) * 86400000

You're probably trying to convert to a UNIX-like timestamp, which are in UTC:

yourDateTime.ToUniversalTime().Subtract(
    new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)
    ).TotalMilliseconds

This also avoids summertime issues, since UTC doesn't have those.

Yes, this program has likely used less than a millsecond. Try using microsecond resolution with timeval.

e.g:

Copy#include <stdio.h>
#include <sys/time.h>

int main(void) {
  struct timeval stop, start;
  gettimeofday(&start, NULL);
  //do stuff
  gettimeofday(&stop, NULL);
  printf("took %lu us\n", (stop.tv_sec - start.tv_sec) * 1000000 + stop.tv_usec - start.tv_usec);
  return 0;
}

You can then query the difference (in microseconds) between stop.tv_usec - start.tv_usec. Note that this will only work for subsecond times (as tv_usec will loop). For the general case use a combination of tv_sec and tv_usec.

Edit 2016-08-19

A more appropriate approach on system with clock_gettime support would be:

Copystruct timespec start, end;
clock_gettime(CLOCK_MONOTONIC_RAW, &start);
//do stuff
clock_gettime(CLOCK_MONOTONIC_RAW, &end);

uint64_t delta_us = (end.tv_sec - start.tv_sec) * 1000000 + (end.tv_nsec - start.tv_nsec) / 1000;

In Python 3 this can be done in 2 steps:

1. Convert timestring to datetime object
2. Multiply the timestamp of the datetime object by 1000 to convert it to milliseconds.

For example like this:

from datetime import datetime

dt_obj = datetime.strptime('20.12.2016 09:38:42,76',
                           '%d.%m.%Y %H:%M:%S,%f')
millisec = dt_obj.timestamp() * 1000

print(millisec)

Output:

1482223122760.0

strptime accepts your timestring and a format string as input. The timestring (first argument) specifies what you actually want to convert to a datetime object. The format string (second argument) specifies the actual format of the string that you have passed.

Here is the explanation of the format specifiers from the official documentation:

• %d - Day of the month as a zero-padded decimal number.
• %m - Month as a zero-padded decimal number.
• %Y - Year with century as a decimal number
• %H - Hour (24-hour clock) as a zero-padded decimal number.
• %M - Minute as a zero-padded decimal number.
• %S - Second as a zero-padded decimal number.
• %f - Microsecond as a decimal number, zero-padded to 6 digits.

It appears to me that the simplest way to do this is

import datetime

epoch = datetime.datetime.utcfromtimestamp(0)

def unix_time_millis(dt):
    return (dt - epoch).total_seconds() * 1000.0