Zastosowanie operatora przecinka C [duplikat]

Myślę, że generalnie przecinek C nie jest dobrym stylem do użycia po prostu dlatego, że jest tak bardzo, bardzo łatwo go przegapić - albo przez kogoś innego, kto próbuje przeczytać/zrozumieć / naprawić Twój kod,albo sam miesiąc w dół linii. Poza deklaracjami zmiennych i oczywiście dla pętli, gdzie jest idiomatyczna.

Można go użyć na przykład do spakowania wielu instrukcji do operatora trójdzielnego (?:), ala:

int x = some_bool ? printf("WTF"), 5 : fprintf(stderr, "No, really, WTF"), 117;

Widziałem go w makrach, gdzie makro udaje funkcję i chce zwrócić wartość, ale najpierw musi wykonać inną pracę. Zawsze jest brzydki i często wygląda jak niebezpieczny hack.

Uproszczony przykład:

#define SomeMacro(A) ( DoWork(A), Permute(A) )

Tutaj B=SomeMacro(A) "zwraca" wynik Permute(A) i przypisuje go do "B".

Dwa zabójcze operatory przecinków w C++:

A) odczyt ze strumienia aż do napotkania określonego ciągu znaków (pomaga utrzymać kod suchy):

 while (cin >> str, str != "STOP") {
   //process str
 }

B) zapisanie złożonego kodu w konstruktorze inicjalizatorów:

class X : public A {
  X() : A( (global_function(), global_result) ) {};
};

Musiałem użyć przecinka do debugowania blokad mutex, aby umieścić wiadomość zanim blokada zacznie czekać.

Nie mogłem usunąć komunikatu logu w ciele pochodnego konstruktora blokady, więc musiałem umieścić go w argumentach konstruktora klasy bazowej używając : baseclass( ( log( "message" ) , actual_arg )) na liście inicjalizacyjnej. Zwróć uwagę na dodatkowy nawias.

Oto wyciąg z klas:

class NamedMutex : public boost::timed_mutex
{
public:
    ...

private:
    std::string name_ ;
};

void log( NamedMutex & ref__ , std::string const& name__ )
{
    LOG( name__ << " waits for " << ref__.name_ );
}

class NamedUniqueLock : public boost::unique_lock< NamedMutex >
{
public:

    NamedUniqueLock::NamedUniqueLock(
        NamedMutex & ref__ ,
        std::string const& name__ ,
        size_t const& nbmilliseconds )
    :
        boost::unique_lock< NamedMutex >( ( log( ref__ , name__ ) , ref__ ) ,
            boost::get_system_time() + boost::posix_time::milliseconds( nbmilliseconds ) ),
            ref_( ref__ ),
            name_( name__ )
    {
    }

  ....

};

Biblioteka Boost Assignment jest dobrym przykładem przeciążenia operatora przecinka w użyteczny, czytelny sposób. Na przykład:

using namespace boost::assign;

vector<int> v; 
v += 1,2,3,4,5,6,7,8,9;

Ze standardu C:

Lewy operand operatora przecinka jest oceniany jako puste wyrażenie; po jego ocenie znajduje się punkt sekwencji. Następnie jest obliczany właściwy operand; wynik ma swój typ i wartość. (Operator przecinka nie daje lvalue.)) Jeśli zostanie podjęta próba modyfikacji wyniku operatora przecinka lub uzyskania do niego dostępu po następnym punkcie sekwencji, zachowanie jest niezdefiniowane.

W skrócie pozwala określić więcej niż jedno wyrażenie, gdzie C oczekuje tylko jednego. Ale w praktyce jest używany głównie w pętlach for.

Zauważ, że:

int a, b, c;

Nie jest operatorem przecinka, jest listą deklaratorów.

Jest czasami używany w makrach, takich jak makra debugowania jak ten:

#define malloc(size) (printf("malloc(%d)\n", (int)(size)), malloc((size)))

Ale jeśli naprawdę tego nie potrzebujesz, lub jesteś pewien, że to sprawia, że kod jest bardziej czytelny i możliwy do utrzymania, polecam nie używać operatora przecinka.

Możesz go przeciążyć(o ile to pytanie ma znacznik " C++"). Widziałem jakiś kod, w którym przeciążony przecinek był używany do generowania macierzy. Albo wektory, nie pamiętam dokładnie. Czyż to nie piękne (choć trochę mylące):

MyVector foo = 2, 3, 4, 5, 6;

Poza pętlą for, I nawet tam jest has może mieć aromat zapachu kodu, jedyne miejsce, które uznałem za dobre użycie operatora przecinka, to część delete:

 delete p, p = 0;

Jedyną wartością nad alternatywą jest to, że możesz przypadkowo skopiować / wkleić tylko połowę tej operacji, jeśli jest ona w dwóch liniach.

Biorąc pod uwagę cytat @ Nicolas Goy ze standardu, to brzmi jakbyś mógł napisać jednolinijkowy dla pętli typu:

int a, b, c;
for(a = 0, b = 10; c += 2*a+b, a <= b; a++, b--);
printf("%d", c);

Jest to bardzo przydatne w dodawaniu komentarza do makr ASSERT:

ASSERT(("This value must be true.", x));

Ponieważ większość makr typu assert wyświetla cały tekst swojego argumentu, dodaje to dodatkowy bit użytecznych informacji do twierdzenia.

Ogólnie unikam używania operatora przecinka, ponieważ po prostu sprawia, że kod jest mniej czytelny. W prawie wszystkich przypadkach prostsze i jaśniejsze byłoby złożenie tylko dwóch oświadczeń. Like:

foo=bar*2, plugh=hoo+7;

Nie daje wyraźnej przewagi nad:

foo=bar*2;
plugh=hoo+7;

Jedyne miejsce poza pętlami, w którym go użyłem to if / else konstruuje, jak:

if (a==1)
... do something ...
else if (function_with_side_effects_including_setting_b(), b==2)
... do something that relies on the side effects ...

Możesz umieścić funkcję przed IF, ale jeśli jej uruchomienie zajmuje dużo czasu, możesz tego uniknąć, jeśli nie jest to konieczne i jeśli funkcja nie powinna być wykonywana, chyba że a!=1, to nie wchodzi w grę. Alternatywą jest zagnieżdżenie IF jako dodatkowej warstwy. To właśnie zwykle robię, ponieważ powyższy kod jest trochę tajemniczy. Ale robiłam to od czasu do czasu przecinkami, ponieważ zagnieżdżanie jest również tajemnicze.

Często używam go do uruchamiania statycznej funkcji inicjującej w niektórych plikach cpp, aby uniknąć leniwych problemów z initalizacją klasycznych singletonów:

void* s_static_pointer = 0;

void init() {
    configureLib(); 
    s_static_pointer = calculateFancyStuff(x,y,z);
    regptr(s_static_pointer);
}

bool s_init = init(), true; // just run init() before anything else

Foo::Foo() {
  s_static_pointer->doStuff(); // works properly
}

Dla mnie jedynym naprawdę użytecznym przypadkiem z przecinkami w C jest użycie ich do wykonania czegoś warunkowego.

  if (something) dothis(), dothat(), x++;

Jest to równoważne

  if (something) { dothis(); dothat(); x++; }

Tu nie chodzi o "mniej pisać", to po prostu wygląda bardzo jasno czasami.

Również pętle są takie same:

while(true) x++, y += 5;

Oczywiście obie mogą być użyteczne tylko wtedy, gdy część warunkowa lub część wykonywalna pętli jest dość mała, dwie-trzy operacje.

Jedyny raz, kiedy widziałem operator , używany poza pętlą for, to wykonanie assingment w trójstyku. To było dawno temu, więc nie mogę zapamiętać dokładnego stwierdzenia, ale było to coś w stylu:

int ans = isRunning() ? total += 10, newAnswer(total) : 0;

Oczywiście żadna osoba przy zdrowych zmysłach nie napisałaby takiego kodu, ale autor był złym geniuszem, który konstruuje instrukcje c w oparciu o wygenerowany przez siebie kod asemblera, a nie czytelność. Na przykład czasami używał pętli zamiast poleceń if, ponieważ preferował wygenerowany przez niego asembler.

Jego kod był bardzo szybki, ale nie do utrzymania, cieszę się, że nie muszę już z nim pracować.

Użyłem go do makra, aby "przypisać wartość dowolnego typu do bufora wyjściowego wskazywanego przez znak*, a następnie zwiększyć wskaźnik o wymaganą liczbę bajtów", tak jak to:

#define ASSIGN_INCR(p, val, type)  ((*((type) *)(p) = (val)), (p) += sizeof(type))

Użycie operatora przecinka oznacza, że makro może być używane w wyrażeniach lub jako instrukcje według życzenia:

if (need_to_output_short)
    ASSIGN_INCR(ptr, short_value, short);

latest_pos = ASSIGN_INCR(ptr, int_value, int);

send_buff(outbuff, (int)(ASSIGN_INCR(ptr, last_value, int) - outbuff));

Zmniejszyło to powtarzalne pisanie, ale musisz uważać, aby nie było zbyt nieczytelne.

Proszę zobaczyć moją zbyt długą wersję tej odpowiedzi tutaj .

Może być przydatny dla "code golf":

Kod: Playing Cubes

, W if(i>0)t=i,i=0; zapisuje dwa znaki.

Qemu ma kod, który używa operatora przecinka w części warunkowej pętli for (Zobacz QTAILQ_FOREACH_SAFE w QEMU-queue.h). To, co zrobili, sprowadza się do następujących rzeczy:

#include <stdio.h>

int main( int argc, char* argv[] ){
  int x = 0, y = 0;

  for( x = 0; x < 3 && (y = x+1,1); x = y ){
    printf( "%d, %d\n", x, y );
  }

  printf( "\n%d, %d\n\n", x, y );

  for( x = 0, y = x+1; x < 3; x = y, y = x+1 ){
    printf( "%d, %d\n", x, y );
  }

  printf( "\n%d, %d\n", x, y );
  return 0;
}

... z następującym wyjściem:

0, 1
1, 2
2, 3

3, 3

0, 1
1, 2
2, 3

3, 4

Pierwsza wersja tej pętli ma następujące efekty:

Pozwala to uniknąć wykonywania dwóch zadań, więc szanse na to, że kod zostanie zsynchronizowany są zmniejszone.]}
• ponieważ używa &&, przypisanie nie jest oceniane po ostatniej iteracji
• ponieważ przypisanie nie jest oceniane, nie będzie próbowało odwoływać się do następnego elementu w kolejce, gdy znajduje się na końcu (w kodzie qemu, Nie w powyższym kodzie).
• wewnątrz pętli masz dostęp do bieżącego i następnego elementu

Znaleziono go w inicjalizacji tablicy:

W C co dokładnie się stanie, jeśli użyję metody () do zainicjalizowania tablicy dwuwymiarowej zamiast {}?

Kiedy inicjalizuję tablicę a[][]:

int a[2][5]={(8,9,7,67,11),(7,8,9,199,89)};

A następnie wyświetla elementy tablicy.

Otrzymuję:

11 89 0 0 0 
0 0 0 0 0