C99复合字面传递给函数参数并通过相同函数返回

Question

我想将UU​​ID转换为C99中的十六进制字符串，然后将其传递给使用引擎盖下方的printf格式的日志函数。我想避免局部变量的单独分配，因为如果禁用日志，则预处理器删除了函数调用，并且该变量未使用，因此发出警告。

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>

typedef struct {
  uint8_t data[8];
} uuid_64_t;

#define UID_64_STR_MAX_SIZE 24

#define UUID_64_TO_STRING(uuid_64, separator, uppercase)      \
  uuid_64_to_string((char[UID_64_STR_MAX_SIZE]){ 0 },         \
                    sizeof((char[UID_64_STR_MAX_SIZE]){ 0 }), \
                    uuid_64,                                  \
                    separator,                                \
                    uppercase)

const char *bytes_to_hex(char *buffer,
                         uint32_t buffer_size,
                         const uint8_t *bytes,
                         uint32_t bytes_size,
                         char separator,
                         bool uppercase)
{
  const char hex_char_uppercase[] = { '0', '1', '2', '3', '4', '5', '6', '7',
                                      '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
  const char hex_char_lowercase[] = { '0', '1', '2', '3', '4', '5', '6', '7',
                                      '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };

  const char *hex_char = uppercase ? hex_char_uppercase : hex_char_lowercase;
  uint32_t total_size, total_separator_size;

  // If the separator is set the null character then no separator is used so
  // the multiplication by zero results in zero total separator size.
  // There is a separator after each two hex characters except for the last two.
  total_separator_size = (bytes_size - 1) * (separator != '\0');

  // One character shall be reserved for the terminating null character
  total_size = 2 * bytes_size + total_separator_size + 1;

  if ((buffer == NULL) || (bytes == NULL) || (buffer_size < total_size)) {
    return "INVALID";
  }

  uint32_t out_idx = 0;
  for (uint32_t in_idx = 0; in_idx < bytes_size; in_idx++) {
    buffer[out_idx++] = hex_char[(bytes[in_idx] >> 4) & 0xF];
    buffer[out_idx++] = hex_char[(bytes[in_idx] >> 0) & 0xF];
    if (separator != '\0' && (in_idx + 1) < bytes_size) {
      buffer[out_idx++] = separator;
    }
  }

  buffer[out_idx] = '\0';
  return buffer;
}

const char *uuid_64_to_string(char *buffer,
                              uint32_t buffer_size,
                              const uuid_64_t *uuid_64,
                              char separator,
                              bool uppercase)
{
  return bytes_to_hex(buffer,
                      buffer_size,
                      uuid_64->data,
                      sizeof(uuid_64->data),
                      separator,
                      uppercase);
}
 
int main(void)
{
    printf("uuid=%s\r\n", UUID_64_TO_STRING(&uuid_64, ':', true));
}

这个想法是通过宏来调用一个函数，该函数将复合文字作为缓冲区参数传递。复合文字分配了一个局部变量，其中uuid_64_to_string函数通过bytes_to_hex函数写入十六进制字符。 UUID_64_TO_STRING返回此传递的复合文字，以直接在类似于printf的日志调用中使用它。 唯一的问题可能是化合物字面意思的寿命，我对此有些不确定。根据C99标准：

化合物字面的价值是未命名对象的价值 由初始化列表初始化。如果复合字面形式发生 在功能主体外，对象具有静态存储 期间;否则，它具有与 封闭块

因此当我解释标准时，这应该是明确定义的行为，因为printf调用和uuid_64_to_string调用在同一块中。 你认为什么？

Answer 1

宏uuid_64_to_string将函数调用扩展到uuid_64_to_string main（）函数中的封闭块。

函数uuid_64_to_string返回其第一个参数，因此指向本地数组的指针。可以将其传递给printf作为参数，因为它指向的对象是C字符串，并且具有涵盖printf呼叫的执行的寿命。

相反，将此指针返回到调用函数或将其存储到当前范围之外使用的指针中是错误的：

int main() {
    printf("uuid=%s\r\n", UUID_64_TO_STRING(&uuid_64, ':', true)); // OK
    return 0;
}

此用途无效：

char *hexify(uuid_64_t *id) {
    return UUID_64_TO_STRING(id, ':', true); // NOT OK
}

int main() {
    printf("uuid=%s\r\n", hexify(&uuid_64)); // NOT OK
    return 0;
}

请注意，范围问题可能很细微：

int main() {
    const char *p = "invalid id";
    if (isValidID(uuid_64))
        p = UUID_64_TO_STRING(&uuid_64, ':', true);

    printf("uuid=%s\r\n", p); // OK
    return 0;
}

int main() {
    const char *p = "invalid id";
    if (isValidID(uuid_64)) {
        p = UUID_64_TO_STRING(&uuid_64, ':', true);
    }
    printf("uuid=%s\r\n", p); // NOT OK
    return 0;
}

虽然此宏似乎有用，应该谨慎使用，可能仅作为函数参数。