如何将负整数连接成字符c语言

Question

我创建了一个脚本来收集以秒和微秒为单位的时间戳。然后我试图计算这些值的差异。只要整数为正，结果就符合预期。

下一步，我将整数转换为字符串，并在它们之间用一个点连接它们。人类可读的格式更容易被用户阅读。

当整数为负数时会出现问题。首先，当我将负 int 转换为字符串时，我无法弄清楚如何打印负号。 （例如 3sec .-3microsec）

其次，如果两个整数都是负数并且我有两个负号，情况可能会变得更糟。 （例如 -3sec .-3microsec）

所以我的问题是，由于我试图减去两个实际上是浮点数的整数，是否还有其他替代方法可以将它们连接成浮点数然后应用减法？ （例如 int 3sec int 3microsec 连接到 float 3.3sec）

我是 C 语言的初学者，所以我不确定这是否可行，这就是我经历了所有这些过程的原因（将 int 转换为字符串，然后进行连接）。

可执行代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <math.h>
#include <sys/timeb.h>
#include <inttypes.h>
#include <assert.h>

#define TIME_CHAR 22
#define PROCESS_CHARACTERS 32

typedef struct rec {
  char time_1[TIME_CHAR];
  char time_2[TIME_CHAR];
  char time_3[TIME_CHAR];
  char process[PROCESS_CHARACTERS];
}RECORD;

char *u2s(long unsigned int number) {

  RECORD *ptr_record = malloc (sizeof(RECORD));

  if (ptr_record == NULL) {
    printf("Out of memory!\nExit!\n");
    exit(0);
  }

  const int n = snprintf(NULL, 0, "%lu", number);
  assert(n > 0);
  char buf[n+1];
  snprintf(buf, n+1, "%lu", number);
  assert(buf[n] == '\0');
  memcpy(ptr_record->process, buf , sizeof buf);

  return ptr_record->process;

}

uint32_t ClockGetTime() {
  struct timespec ts;
  clock_gettime(CLOCK_REALTIME, &ts);
  return (int32_t)ts.tv_sec * 1000000LL + (int32_t)ts.tv_nsec / 1000LL;
}

void cleanup(RECORD** ptr_record) {
  free(*ptr_record);
  *ptr_record = NULL;
}

int main(int argc, char *argv[]) {

  char *dot = ".";
  RECORD *ptr_record;

  ptr_record = malloc (sizeof(RECORD));

  if (ptr_record == NULL) {
    printf("Out of memory!\nExit!\n");
    exit(0);
  }

  /* Originate Time Stamps for time_1 */
  time_t time_1_sec = time(NULL);
  uint32_t client_1_sec = time_1_sec;
  uint32_t client_1_microsec = ClockGetTime();

  char *client_1_sec_string = u2s(client_1_sec);
  char *client_1_microsec_string = u2s(client_1_microsec);

  memset( ptr_record->time_1 , '\0' , sizeof ptr_record->time_1 );
  strncat( ptr_record->time_1 , client_1_sec_string , strlen(client_1_sec_string) );
  strncat( ptr_record->time_1 , dot , strlen(dot) );
  strncat( ptr_record->time_1 , client_1_microsec_string ,     strlen(client_1_microsec_string) );

  /* Originate Time Stamps for time_2 */
  time_t time_2_sec = time(NULL);
  uint32_t client_2_sec = time_2_sec;
  uint32_t client_2_microsec = ClockGetTime();

  char *client_2_sec_string = u2s(client_2_sec);
  char *client_2_microsec_string = u2s(client_2_microsec);

  memset( ptr_record->time_2 , '\0' , sizeof ptr_record->time_2 );
  strncat( ptr_record->time_2 , client_2_sec_string , strlen(client_2_sec_string) );
  strncat( ptr_record->time_2 , dot , strlen(dot) );
  strncat( ptr_record->time_2 , client_2_microsec_string , strlen(client_2_microsec_string) );

  printf("This is buffer time_2: %s\n",ptr_record->time_2);

  int32_t d_positive_sec = client_2_sec - client_1_sec;
  int32_t d_positive_microsec = client_2_microsec - client_1_microsec;

  printf("This is the positive difference in sec: %"PRId32"\n",d_positive_sec);
  printf("This is the positive difference in microsec: %"PRId32"\n",d_possitive_microsec);

  int32_t d_negative_sec = client_1_sec - client_2_sec;
  int32_t d_negative_microsec = client_1_microsec - client_2_microsec;

  printf("This is the negative difference in sec: %"PRId32"\n",d_negative_sec);
  printf("This is the negative difference in microsec: %"PRId32"\n",d_negative_microsec);

  char *n_sec_string = u2s(d_negative_sec);
  char *n_microsec_string = u2s(d_negative_microsec);

  memset( ptr_record->time_3 , '\0' , sizeof ptr_record->time_3 );
  strncat( ptr_record->time_3 , n_sec_string , strlen(n_sec_string) );
  strncat( ptr_record->time_3 , dot , strlen(dot) );
  strncat( ptr_record->time_3 , n_microsec_string , strlen(n_microsec_string) );

  printf("This is negative concatenated %s\n",ptr_record->time_3);

  cleanup(&ptr_record);

  return 0;

} /* End of main(){} */

输出样本：

This is the positive difference in sec: 0
This is the positive difference in microsec: 37
This is the negative difference in sec: 0
This is the negative difference in microsec: -37
This is negative concatenated 0.18446744073709551579

很容易看出，在我们应该期望看到 (0.-37) 的串联之后，最好的结果将是 (-0.37)。

Answer 1

You can/should read all about printf format conversions at:

<http://en.wikipedia.org/wiki/Printf_format_string#Format_placeholders>

which states:

the full syntax of a conversion parameter is:
**%[parameter][flags][width][.precision][length]type**
where [parameter] is a posix extension ... (see linked page for details)

标志可以是零个或多个（以任何顺序）：

Character   Description
**+     always denote the sign '+' or '-' of a number (the default is to omit the sign for positive numbers). Only applicable to numeric types.**
space   prefixes non-negative signed numbers with a space
-   left-align the output of this placeholder (the default is to right-align the output).
#   Alternate form. For 'g' and 'G', trailing zeros are not removed. For 'f', 'F', 'e', 'E', 'g', 'G', the output always contains a decimal point. For 'o', 'x', and 'X', a 0, 0x, and 0X, respectively, is prepended to non-zero numbers.
0   use 0 instead of spaces to pad a field when the width option is specified. For example, printf("%2d", 3) results in " 3", while printf("%02d", 3) results in "03".

宽度指定要输出的最小字符数，通常用于填充列表输出中的固定宽度字段，否则字段会更小，尽管它不会导致截断过大的字段。宽度值中的前导零被解释为上面提到的补零标志，负值与上面也提到的左对齐“-”标志一起被视为正值。

精度通常指定输出的最大限制，具体取决于特定的格式类型。对于浮点数字类型，它指定输出应舍入的小数点右侧的位数。对于字符串类型，它限制了应该输出的字符数，之后字符串被截断。

长度可以省略，也可以是：

Character   Description
hh  For integer types, causes printf to expect an int-sized integer argument which was promoted from a char.
h   For integer types, causes printf to expect an int-sized integer argument which was promoted from a short.
l   For integer types, causes printf to expect a long-sized integer argument.

For floating point types, causes printf to expect a double argument.
ll  For integer types, causes printf to expect a long long-sized integer argument.
L   For floating point types, causes printf to expect a long double argument.
z   For integer types, causes printf to expect a size_t-sized integer argument.
j   For integer types, causes printf to expect a intmax_t-sized integer argument.

so just include the '+' flag in the format conversion parameter and 
if the value is negative, then a '-' will be printed in the output
t   For integer types, causes printf to expect a ptrdiff_t-sized integer argument.

Answer 2

OP 获取时间的方法有缺陷。它从 2 个调用中检索 second 和 microsecond，但在 2 个调用之间经过了时间，并且秒数可能会增加。相反，重写ClockGetTime() 以获得sec 和microsec。

// time_t time_1_sec = time(NULL);
// uint32_t client_1_sec = time_1_sec;
// uint32_t client_1_microsec = ClockGetTime();

正如@alk 所建议的那样，转换为一个共同的比例，然后减去

// int32_t d_positive_sec = client_2_sec - client_1_sec;
// int32_t d_positive_microsec = client_2_microsec - client_1_microsec;
// printf("This is the positive difference in sec: %"PRId32"\n",d_positive_sec);
// printf("This is the positive difference in microsec: %"PRId32"\n",     
//     d_possitive_microsec);

int64_t t1 = client_1_sec;
t1 = t1*1000000 /* microseconds per second */ + client_1_microsec;
int64_t t2 = client_2_sec;
t2 = t2*1000000 + client_2_microsec;
int64_t diff = t2 - t1;
int64_t diff_sec = diff/1000000;
int32_t diff_usec = diff%1000000;
if (diff_usec < 0) diff_usec = -diff_usec;

printf("Difference: %" PRId64 ".%06" PRId32 " sec\n", diff_sec, diff_usec);

转换为float 通常不会提供足够的精度。转换为 double 通常对于 32 位 int 和 ~20 位 usec 来说足够精确。这是另一种方法。

double t1 = client_1_sec;
t1 = t1*1000000 /* microseconds per second */ + client_1_microsec;
double t2 = client_2_sec;
t2 = t2*1000000 + client_2_microsec;
double diff = t2 - t1;

printf("Difference: %0.6f sec\n", diff);

---

总体而言，建议改用int64_t 来存储来自clock_gettime() 的秒数和纳秒数，并将其用于差异计算。

int64_t ClockGetTime(void) {
  struct timespec ts;
  if (clock_gettime(CLOCK_REALTIME, &ts)) Handle_Error();
  return ts.tv_sec * ((int64_t)1000000000) + ts.tv_nsec;
}

---

小提示

u2s 在构造数字的字符串表示形式时，做了很多工作以小心不要溢出buf。然而它很高兴memcpy(ptr_record->process, buf , sizeof buf) 没有检查sizeof buf <= sizeof ptr_record->process。