## önişlemci operatörünün uygulamaları ve dikkate alınması gereken şeyler nelerdir?

Önceki sorularımın çoğunda belirtildiği gibi, K&R ile çalışıyorum ve şu anda ön işlemcideyim. Daha ilginç şeylerden biri - önceki C öğrenme girişimlerimden daha önce hiç bilmediğim bir şey - ##önişlemci operatörüdür. K & R'ye göre:

Önişlemci operatörü ## , makro genişletme sırasında gerçek bağımsız değişkenleri birleştirmek için bir yol sağlar. Değiştirme metnindeki bir parametre a'ya bitişikse ##, parametre gerçek bağımsız değişkenle değiştirilir, ##ve çevresindeki beyaz boşluk kaldırılır ve sonuç yeniden taranır. Örneğin, makro paste iki bağımsız değişkenini birleştirir:

#define paste(front, back) front ## back

böylece paste(name, 1)jetonu oluşturur name1.

Birisi bunu gerçek dünyada nasıl ve neden kullanır? Kullanımının pratik örnekleri nelerdir ve dikkate alınması gereken şeyler var mı?

CrashRpt: Makro çok baytlı dizeleri Unicode'a dönüştürmek için ## kullanma

CrashRpt'deki (kilitlenme raporlama kitaplığı) ilginç bir kullanım şudur:

#define WIDEN2(x) L ## x
#define WIDEN(x) WIDEN2(x)
//Note you need a WIDEN2 so that __DATE__ will evaluate first.

Burada karakter başına bir baytlık bir dizge yerine iki baytlık bir dizge kullanmak istiyorlar. Bu muhtemelen gerçekten anlamsız gibi görünüyor, ancak bunu iyi bir sebeple yapıyorlar.

 std::wstring BuildDate = std::wstring(WIDEN(__DATE__)) + L" " + WIDEN(__TIME__);

Tarih ve saatle birlikte bir dize döndüren başka bir makro ile kullanırlar.

A'nın Lyanına koymak __ DATE __size bir derleme hatası verir.

Windows: Genel Unicode veya çok baytlı dizeler için ## kullanma

Windows, aşağıdaki gibi bir şey kullanır:

#ifdef  _UNICODE
    #define _T(x)      L ## x
#else
    #define _T(x) x
#endif

Ve _Tkodun her yerinde kullanılır

Temiz erişimci ve değiştirici adları için kullanılan çeşitli kitaplıklar:

Ayrıca erişimcileri ve değiştiricileri tanımlamak için kodda kullanıldığını gördüm:

#define MYLIB_ACCESSOR(name) (Get##name)
#define MYLIB_MODIFIER(name) (Set##name)

Aynı şekilde, diğer akıllı ad oluşturma türleri için de aynı yöntemi kullanabilirsiniz.

Aynı anda birkaç değişken bildirimi yapmak için kullanan çeşitli kitaplıklar:

#define CREATE_3_VARS(name) name##1, name##2, name##3
int CREATE_3_VARS(myInts);
myInts1 = 13;
myInts2 = 19;
myInts3 = 77;

Belirteç yapıştırma (' ##') veya #ön işleme (' ') ön işleme operatörlerini kullanırken dikkat etmeniz gereken bir şey, bunların her durumda düzgün çalışması için fazladan bir indirme seviyesi kullanmanız gerektiğidir.

Bunu yapmazsanız ve belirteç yapıştırma operatörüne iletilen öğelerin kendileri makrolarsa, muhtemelen istediğiniz gibi olmayan sonuçlar alırsınız:

#include <stdio.h>

#define STRINGIFY2( x) #x
#define STRINGIFY(x) STRINGIFY2(x)
#define PASTE2( a, b) a##b
#define PASTE( a, b) PASTE2( a, b)

#define BAD_PASTE(x,y) x##y
#define BAD_STRINGIFY(x) #x

#define SOME_MACRO function_name

int main() 
{
    printf( "buggy results:\n");
    printf( "%s\n", STRINGIFY( BAD_PASTE( SOME_MACRO, __LINE__)));
    printf( "%s\n", BAD_STRINGIFY( BAD_PASTE( SOME_MACRO, __LINE__)));
    printf( "%s\n", BAD_STRINGIFY( PASTE( SOME_MACRO, __LINE__)));

    printf( "\n" "desired result:\n");
    printf( "%s\n", STRINGIFY( PASTE( SOME_MACRO, __LINE__)));
}

Çıktı:

buggy results:
SOME_MACRO__LINE__
BAD_PASTE( SOME_MACRO, __LINE__)
PASTE( SOME_MACRO, __LINE__)

desired result:
function_name21

İşte bir derleyicinin yeni bir sürümüne yükseltirken karşılaştığım bir sorun:

Belirteç yapıştırma operatörünün ( ##) gereksiz kullanımı taşınabilir değildir ve istenmeyen boşluklar, uyarılar veya hatalar oluşturabilir.

Belirteç yapıştırma işlecinin sonucu geçerli bir ön işlemci belirteci olmadığında belirteç yapıştırma işleci gereksizdir ve muhtemelen zararlıdır.

Örneğin, belirteç yapıştırma operatörünü kullanarak derleme zamanında dize değişmezleri oluşturmaya çalışılabilir:

#define STRINGIFY(x) #x
#define PLUS(a, b) STRINGIFY(a##+##b)
#define NS(a, b) STRINGIFY(a##::##b)
printf("%s %s\n", PLUS(1,2), NS(std,vector));

Bazı derleyicilerde bu, beklenen sonucu verir:

1+2 std::vector

Diğer derleyicilerde bu, istenmeyen boşlukları içerecektir:

1 + 2 std :: vector

GCC'nin oldukça modern sürümleri (> = 3.3 ya da öylesine) bu kodu derleyemeyecektir:

foo.cpp:16:1: pasting "1" and "+" does not give a valid preprocessing token
foo.cpp:16:1: pasting "+" and "2" does not give a valid preprocessing token
foo.cpp:16:1: pasting "std" and "::" does not give a valid preprocessing token
foo.cpp:16:1: pasting "::" and "vector" does not give a valid preprocessing token

Çözüm, önişlemci belirteçlerini C / C ++ operatörleriyle birleştirirken belirteç yapıştırma işlecini çıkarmaktır:

#define STRINGIFY(x) #x
#define PLUS(a, b) STRINGIFY(a+b)
#define NS(a, b) STRINGIFY(a::b)
printf("%s %s\n", PLUS(1,2), NS(std,vector));

Birleştirme hakkındaki GCC CPP belgeleri bölümü , belirteç yapıştırma operatörü hakkında daha yararlı bilgiler içerir.

Bu, kendinizi gereksiz yere tekrar etmemek için her türlü durumda yararlıdır. Aşağıda Emacs kaynak kodundan bir örnek verilmiştir. Bir kitaplıktan birkaç işlev yüklemek istiyoruz. "Foo" işlevi atanmalıdır fn_foo, vb. Aşağıdaki makroyu tanımlıyoruz:

#define LOAD_IMGLIB_FN(lib,func) {                                      \
    fn_##func = (void *) GetProcAddress (lib, #func);                   \
    if (!fn_##func) return 0;                                           \
  }

Daha sonra onu kullanabiliriz:

LOAD_IMGLIB_FN (library, XpmFreeAttributes);
LOAD_IMGLIB_FN (library, XpmCreateImageFromBuffer);
LOAD_IMGLIB_FN (library, XpmReadFileToImage);
LOAD_IMGLIB_FN (library, XImageFree);

Bunun yararı, her ikisini de yazmak zorunda kalmamak fn_XpmFreeAttributesve "XpmFreeAttributes"(ve bunlardan birini yanlış yazma riskini almak).

Stack Overflow ile ilgili önceki bir soru, çok fazla hataya açık yeniden yazma olmadan numaralandırma sabitleri için dize temsilleri oluşturmanın sorunsuz bir yöntemini istedi.

Bağlantı

Bu soruya cevabım, küçük önişlemci sihrinin uygulanmasının numaralandırmanızı nasıl bu şekilde tanımlamanıza izin verdiğini gösterdi (örneğin) ...;

ENUM_BEGIN( Color )
  ENUM(RED),
  ENUM(GREEN),
  ENUM(BLUE)
ENUM_END( Color )

... Makro genişletmenin yalnızca numaralandırmayı (bir .h dosyasında) değil, aynı zamanda eşleşen bir dizge dizisini de (bir .c dosyasında) tanımlaması avantajı ile;

const char *ColorStringTable[] =
{
  "RED",
  "GREEN",
  "BLUE"
};

Dize tablosunun adı, makro parametresinin (yani Renk) ## operatörü kullanılarak StringTable'a yapıştırılmasından gelir. Bunun gibi uygulamalar (püf noktaları?) # Ve ## operatörlerinin paha biçilmez olduğu yerlerdir.

Makro parametrelerini başka bir şeyle birleştirmeniz gerektiğinde belirteç yapıştırmayı kullanabilirsiniz.

Şablonlar için kullanılabilir:

#define LINKED_LIST(A) struct list##_##A {\
A value; \
struct list##_##A *next; \
};

Bu durumda LINKED_LIST (int) size

struct list_int {
int value;
struct list_int *next;
};

Benzer şekilde, liste geçişi için bir işlev şablonu yazabilirsiniz.

Bir tür arama kuralına uyması gereken bir dizi yöntem için prototipleri doğru şekilde uygulamaya yardımcı olmak için C programlarında kullanıyorum. Bir bakıma, bu, düz C'deki kötü adamın nesne yönelimi için kullanılabilir:

SCREEN_HANDLER( activeCall )

bunun gibi bir şeye genişler:

STATUS activeCall_constructor( HANDLE *pInst )
STATUS activeCall_eventHandler( HANDLE *pInst, TOKEN *pEvent );
STATUS activeCall_destructor( HANDLE *pInst );

Bu, şunları yaptığınızda tüm "türetilmiş" nesneler için doğru parametrelendirmeyi zorlar:

SCREEN_HANDLER( activeCall )
SCREEN_HANDLER( ringingCall )
SCREEN_HANDLER( heldCall )

üstbilgi dosyalarınızda, vb. yukarıdakiler, tanımları değiştirmek ve / veya "nesnelere" yöntemler eklemek istemeniz durumunda bile bakım için yararlıdır.

SGlib , C'deki şablonları temelde dolaştırmak için ## kullanır. İşlev aşırı yüklemesi olmadığından, ## tür adını oluşturulan işlevlerin adlarına yapıştırmak için kullanılır. List_t adında bir liste türüne sahip olsaydım, sglib_list_t_concat gibi adlandırılmış işlevler alırdım ve benzeri.

Gömülü için standart olmayan bir C derleyicisinde ev haddelenmiş bir iddia için kullanıyorum:

#define ASSERT(exp) if(!(exp)){ \
                      print_to_rs232("Assert failed: " ## #exp );\
                      while(1){} //Let the watchdog kill us 

Makrolar tarafından tanımlanan değişkenlere özel önekler eklemek için kullanıyorum. Yani şöyle bir şey:

UNITTEST(test_name)

şuna genişler:

void __testframework_test_name ()

Ana kullanım, bir adlandırma kuralınız olduğunda ve makronuzun bu adlandırma kuralından yararlanmasını istediğiniz zamandır. Belki birkaç yöntem ailesiniz vardır: image_create (), image_activate () ve image_release () ayrıca file_create (), file_activate (), file_release () ve mobile_create (), mobile_activate () ve mobile_release ().

Nesne yaşam döngüsünü işlemek için bir makro yazabilirsiniz:

#define LIFECYCLE(name, func) (struct name x = name##_create(); name##_activate(x); func(x); name##_release())

Tabii ki, bir tür "nesnelerin minimal versiyonu", bunun geçerli olduğu tek adlandırma kuralı değildir - adlandırma kurallarının neredeyse büyük çoğunluğu, adları oluşturmak için ortak bir alt dizeden yararlanır. İsimleri (yukarıdaki gibi) veya alan isimlerini, değişken isimlerini veya başka herhangi bir şeyi işlevlendirebilirim.

WinCE'de önemli bir kullanım:

#define BITFMASK(bit_position) (((1U << (bit_position ## _WIDTH)) - 1) << (bit_position ## _LEFTSHIFT))

Register bit tanımlamasını tanımlarken şunları yapıyoruz:

#define ADDR_LEFTSHIFT                          0

#define ADDR_WIDTH                              7

Ve BITFMASK'ı kullanırken, sadece şunu kullanın:

BITFMASK(ADDR)

Günlük kaydı için çok kullanışlıdır. Yapabilirsin:

#define LOG(msg) log_msg(__function__, ## msg)

Veya derleyiciniz function ve func'u desteklemiyorsa :

#define LOG(msg) log_msg(__file__, __line__, ## msg)

Yukarıdaki "işlevler" mesajı günlüğe kaydeder ve tam olarak hangi işlevin bir ileti kaydettiğini gösterir.

C ++ sözdizimim tam olarak doğru olmayabilir.