Забудь про псевдокрасивости. Важна только читабельность кода, поэтому не выпендривийся и пиши прямо.

const char* str = get_my_string();
if (str == NULL)
  str = "unknown";

printf("My string is %s", str);

или

const char* string_or(const char* string, const char* or) {
  if (string)
    return string;
  return or;
}
...
printf("My string is %s", string_or(get_my_string(), "unknown"));

Инкрементирую этого адеквата. Все, кто пишут однострочники — пидо^Wплохо относятся к людям, которые будут читать их код.

Смешно звучит от чувака с лямбдой на аватарке.

Ты всё правильно пишешь, осталось сделать последний шаг:

printf("My string is %s", get_my_string() ?: "unknown");

gcc-only

Ну, раз вы тут наркоманите:

#include <stdio.h>

char *
get_my_string()
{
        return NULL;
}

int
main()
{
        char *s;
        printf("My string is %s\n", (s = get_my_string(), s ? s : "unknown"));
        return 0;
}

UPD:

printf("My string is %s\n", get_my_string() ?: "unknown");

d

Смешно звучит от чувака с лямбдой на аватарке.

Я же не фанатик, а самый таки обычный программист за еду.

Касательно ?: — А, вообще, если хорошо подумать — это не очень хорошее gnu расширение:

A GNU extension to C allows omitting the second operand, and using implicitly the first operand as the second also:

a = x ? : y;

The expression is equivalent to

a = x ? x : y;

except that if x is an expression, it is evaluated only once. The difference is significant if evaluating the expression has side effects.

ref: http://en.wikipedia.org/wiki/?:

Что не очень хорошего?

Специально же выделил:

except that if x is an expression, it is evaluated only once

?: (ровно как и ? x :) на каждом шагу использовать не стоит, слишком там уж много условностей. Лучше уж-таки простым условием, а если свербит, то прописать макрос для препроцессора.

Это как раз-таки очень хорошо.

x 1 раз упомянут, 1 раз вычислен. Логично. Не очень хорошо было бы обратное.

Первый вариант окей, только if надо со скобочками писать.

И чем же твоё говно читабельней? Тем, что вместо 100строк я получу овер1к? Отлично - это же так удобно, когда вместо взгляда на полный код - я скролю как мразь.

Эти нулёвые if(str == NULL), это неосиляторство ?: и пацан рождает говняную лапшу. Хорошо хоть додумался спастить функцию у пацанов.

Интересно, а в реальном мире вообще есть код типа

int a = (expression-with-side-effects) ? (expression-with-side-effects) : something;

Просто подобная хрень, имхо, похожа на баг.

nullptr

а если сделать get_my_string() возвращать строку или 0?

годнота

#define or(A, B) (A != NULL ? (A) : (B))

А будет вычислено дважды

что за дурдом? блин вы бы просто проверили: printf(«my string: %s\n», NULL);

за вас все давно уже сделано

Так делать не стоит, максимум для отладки. http://stackoverflow.com/a/11589500

Забудь про псевдокрасивости. Важна только читабельность кода, поэтому не выпендривийся и пиши прямо.

Как же ты прав, дорогой человек. К слову, мне безумно нравится в Go, что там просто нельзя сделать иначе.

Почему множественные глобальные неинициализированные переменные с одинаковыми именами и разными типами не приводят к ошибке компиляции?

$ cat run.sh
#!/bin/bash

ls

cat >a.c <<EOF
char global;
int get_a(void) { return global; }
void set_a(int value) { global = value; }
EOF

cat >b.c <<EOF
int global;
int get_b(void) { return global; }
void set_b(int value) { global = value; }
EOF

cat >c.c <<EOF
float global;
int get_c(void) { return global; }
void set_c(int value) { global = value; }
EOF

cat >main.c <<EOF
#include <stdio.h>
int get_a(void); void set_a(int);
int get_b(void); void set_b(int);
int get_c(void); void set_c(int);
void p(void) {
  printf("%i %i %i\n",
    get_a(), get_b(), get_c()
  );
}
int main() {
  set_a(1); p();
  set_b(2); p();
  set_c(3); p();
  set_a(4); p();
  set_b(5); p();
  set_c(6); p();
  return 0;
}
EOF

gcc -Wall -Wextra -pedantic -ansi *.c -o main
./main
$ ./run.sh
run.sh
1 1 0
2 2 0
0 1077936128 3
4 1077936132 3
5 5 0
0 1086324736 6

https://gcc.gnu.org/onlinedocs/gcc-4.9.2/gcc/Code-Gen-Options.html#index-fno-...

Спасибо тебе, выручил.

Ты чертовски прав!

Вообще, возврат некоторой функции вместо реального значения некоторого NULL по смыслу может быть по трем причинам:

1) Функция должна сигнализировать о том, что что-то пошло не так. Тогда она должна возвращать NULL, и результат должен явно проверяться if (result==null)...

2) Функция возвращает NULL, но это нормально, это не сигнал о том, что что-то пошло не так. Тогда функция не должна возвращать NULL, и проверку надо перенести в саму функцию return (result==NULL) ? «unknown» : result

3) Функция возвращает NULL, и в одних случаях это сигнал о том, что что-то пошло не так, а в других случаях это нормально - например в случае печати. Тогда функция должна возвращать NULL и он должен в одних местах обрабатываться явно if (result==NULL), а в других местах, например для печати, мне кажется выгоднее завести функцию const char *printable(const char *) приводящую все возможные результаты исходной функции к печатному виду.

Если выражаться более формально: есть функция f возвращающая результат из домена Ef, и функция g, принимающая параметр из домена Dg. Предположим, Ef не совпадает с Dg, а мы хотим использовать функции так g(f()). Тогда нам нужно написать функцию h, переводящую Ef в Dg, и использовать их так g(h(f())).

Рассмотрим теперь домен X=Ef\Dg. Если в X нет значений, которые мы хотим обрабатывать особым образом (то есть любым образом, кроме передачи в g), то мы можем не определять отдельно f, а определить сразу h*f. Или, если это возможно, сразу определить g*h. Если не возможно ни то, ни другое, то придётся определить отдельно f и g, и в этом случае, мне кажется, намерения будут в коде видны яснее, если явно определить h.

Конечно, иногда для одной f много разных g1...gN, с параметрами из разных доменов. Выгодно или нет определять функции перевода для всех этих доменов, - это решит ситуация.

В рассматриваемом случае f() это get_string(), Ef это множество всех действительных строк и NULL, g(s) это printf(«My string is %s\n», s), Dg это множество всех действительных строк, f(s) это printable(s) сопоставляющая значению NULL действительную строку «unknown», h*f это то же самое, что перенести проверку на NULL в функцию get_string(), g*h это то же самое, что и включить в printf тернарный оператор или выполнить проверку на NULL перед printf. Как бы то ни было, если вы будете держать такой взгляд на происходящее в уме, у вас появится возможность осознанно выбирать между вариантами, а не зацикливаться на одном.

Вообще, возврат некоторой функции вместо реального значения некоторого NULL по смыслу может быть по трем причинам

Плюсую, это все излишние навороты. Классика жанра:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int
get_my_string( char * out, int len )
{
    if ( len >= 4 )
      {
        strcpy( out, "good" );
        return 1;
      }

    /* error */
    return 0;
}

int main ( void )
{
    int length = 100;
    char * out = malloc( length * sizeof(char) );
    printf( "My string is %s\n",
            get_my_string( out, length ) ? out : "unknown" );
    free( out );

    return 0;
}

nullptr

Тогда придется заменить и C на C++.

разумеется)

3) Функция возвращает NULL, и в одних случаях это сигнал о том, что что-то пошло не так, а в других случаях это нормально

бьём этого погромиста (например) «совершенным кодом» по голове до тех пор пока он не перестанет так делать

GNU dlsym() отличный тому пример.

Компилятор такое не съел.

что сказал?

1) Функция должна сигнализировать о том, что что-то пошло не так. Тогда она должна возвращать NULL, и результат должен явно проверяться if (result==null)...

Голуб смотрит на тебя с презрением.

лови:

   const char *t = get_my_string();
   printf("%s\n", t? t: "unknown");

Полностью поддерживаю.

Аллен Голуб бох, а emulek пророкъ его! 😊

emulek пророкъ его!

К тому же, многие программисты избегают условной операции (?:) просто потому, что она им кажется непонятной. Тем не менее, это условное выражение может существенно упростить ваш код и, следственно, сделать его лучше читаемым. Я думаю, что:

printf("%s", str ? str : "<пусто>");  

if ( str == NULL )  
 printf( "<пусто>" );  
else  
 printf( "%s", str );  

while ( *p )  
{ 
 putchar ( *p );  
++p;  
}  

for ( ; *p ; ++p ) 
 putchar ( *p );  

while ( *p ) 
 putchar ( *p++ );  

а ничего, что твоя get_my_string() дважды вызывается?

Интересно, а в реальном мире вообще есть код типа

а как же!

Просто подобная хрень, имхо, похожа на баг.

конечно это баг: строка же откуда-то _берётся_, сначала одну возьмёт и проверит, потом _вторую_ использует.

А будет вычислено дважды

A может быть вычислено дважды.

    if ( len >= 4 )
      {
        strcpy( out, "good" );

Хе-хе, классика сипроблем: дотационный нуль-терминатор.

И get_my_string будет вызвана дважды

Может быть, да