C ++ makroları ne zaman faydalıdır? [kapalı]

C önişlemci haklı korkulan ve C ++ topluluğu tarafından diğerlerinden ayrı tutulur. Satır içi işlevler, sabitler ve şablonlar genellikle a'ya daha güvenli ve üstün bir alternatiftir #define.

Aşağıdaki makro:

#define SUCCEEDED(hr) ((HRESULT)(hr) >= 0)  

hiçbir şekilde kasa tipinden daha üstün değildir:

inline bool succeeded(int hr) { return hr >= 0; }

Ama siz makrolar makro bulmak kullanımları listelenmektedir lütfen onların yerine sahip olduğunuzu sen yapamazsın önişlemci olmadan .

Lütfen her kullanım senaryosunu ayrı bir cevaba koyun, böylece oy verilebilir ve eğer preprosesör olmadan cevaplardan birine nasıl ulaşılacağını biliyorsanız, bu cevabın yorumlarında nasıl olduğunu gösterin.

Ayıklama fonksiyonları için sargılar gibi, otomatik gibi şeyler geçmek __FILE__, __LINE__vb:

#ifdef ( DEBUG )
#define M_DebugLog( msg )  std::cout << __FILE__ << ":" << __LINE__ << ": " << msg
#else
#define M_DebugLog( msg )
#endif

Yöntemler her zaman eksiksiz, derlenebilir kod olmalıdır; makrolar kod parçaları olabilir. Böylece bir foreach makrosu tanımlayabilirsiniz:

#define foreach(list, index) for(index = 0; index < list.size(); index++)

Ve bu şekilde kullanın:

foreach(cookies, i)
    printf("Cookie: %s", cookies[i]);

C ++ 11'den bu yana, döngü için aralık tabanlı olur .

Başlık dosyası korumaları makroları gerektirir.

Makro gerektiren başka alanlar var mı? Çok değil (varsa).

Makrolardan yararlanan başka durumlar var mı? EVET!!!

Makroları kullandığım bir yer çok tekrarlı kod. Örneğin, diğer arabirimlerle (.NET, COM, Python, vb ...) kullanılacak C ++ kodunu kaydırırken, farklı özel durum türlerini yakalamam gerekir. İşte bunu nasıl yaparım:

#define HANDLE_EXCEPTIONS \
catch (::mylib::exception& e) { \
    throw gcnew MyDotNetLib::Exception(e); \
} \
catch (::std::exception& e) { \
    throw gcnew MyDotNetLib::Exception(e, __LINE__, __FILE__); \
} \
catch (...) { \
    throw gcnew MyDotNetLib::UnknownException(__LINE__, __FILE__); \
}

Bu yakalamaları her sarmalayıcı işlevine koymam gerekiyor. Her seferinde tam catch bloklarını yazmak yerine, sadece şunu yazarım:

void Foo()
{
    try {
        ::mylib::Foo()
    }
    HANDLE_EXCEPTIONS
}

Bu aynı zamanda bakımı kolaylaştırır. Yeni bir istisna türü eklemem gerekirse, eklemem gereken tek bir yer var.

Başka yararlı örnekler de vardır: birçoğu __FILE__ve __LINE__önişlemci makrolarını içerir.

Her neyse, makrolar doğru kullanıldığında çok kullanışlıdır. Makrolar kötü değildir - kötüye kullanımları kötülüktür.

Çoğunlukla:

1. Muhafızları dahil et
2. Koşullu derleme
3. Raporlama ( __LINE__ve benzeri önceden tanımlanmış makrolar__FILE__ )
4. (nadiren) Yinelenen kod modellerini çoğaltma.
5. Rakibinizin kodunda.

Koşullu derleme içinde, derleyiciler arasındaki farkların üstesinden gelmek için:

#ifdef ARE_WE_ON_WIN32
#define close(parm1)            _close (parm1)
#define rmdir(parm1)            _rmdir (parm1)
#define mkdir(parm1, parm2)     _mkdir (parm1)
#define access(parm1, parm2)    _access(parm1, parm2)
#define create(parm1, parm2)    _creat (parm1, parm2)
#define unlink(parm1)           _unlink(parm1)
#endif

İfadeden bir dize yapmak istediğinizde, bunun en iyi örneği assert( #xdeğerini xbir dizeye dönüştürür).

#define ASSERT_THROW(condition) \
if (!(condition)) \
     throw std::exception(#condition " is false");

Dize değişmezleri ile a'dan daha fazlasını yapabildiğinizden, dize sabitleri bazen makro olarak daha iyi tanımlanır const char *.

Örn. String değişmezleri kolayca birleştirilebilir .

#define BASE_HKEY "Software\\Microsoft\\Internet Explorer\\"
// Now we can concat with other literals
RegOpenKey(HKEY_CURRENT_USER, BASE_HKEY "Settings", &settings);
RegOpenKey(HKEY_CURRENT_USER, BASE_HKEY "TypedURLs", &URLs);

A const char *kullanıldıysa, çalışma zamanında birleştirmeyi gerçekleştirmek için bir çeşit dize sınıfı kullanılmalıdır:

const char* BaseHkey = "Software\\Microsoft\\Internet Explorer\\";
RegOpenKey(HKEY_CURRENT_USER, (string(BaseHkey) + "Settings").c_str(), &settings);
RegOpenKey(HKEY_CURRENT_USER, (string(BaseHkey) + "TypedURLs").c_str(), &URLs);

Bir işlevdeki program akış ( return, breakve continue) kodunu değiştirmek istediğinizde , işlevde aslında satır içi olan koddan farklı davranır.

#define ASSERT_RETURN(condition, ret_val) \
if (!(condition)) { \
    assert(false && #condition); \
    return ret_val; }

// should really be in a do { } while(false) but that's another discussion.

Bariz muhafızlar

#ifndef MYHEADER_H
#define MYHEADER_H

...

#endif

Normal bir işlev çağrısı kullanarak işlev çağrısı bağımsız değişkenlerini kısa devre gerçekleştiremezsiniz. Örneğin:

#define andm(a, b) (a) && (b)

bool andf(bool a, bool b) { return a && b; }

andm(x, y) // short circuits the operator so if x is false, y would not be evaluated
andf(x, y) // y will always be evaluated

Diyelim ki başlık muhafızları gibi belirgin şeyleri görmezden geleceğiz.

Bazen, ön derleyici tarafından kopyalanması / yapıştırılması gereken kodlar oluşturmak istersiniz:

#define RAISE_ERROR_STL(p_strMessage)                                          \
do                                                                             \
{                                                                              \
   try                                                                         \
   {                                                                           \
      std::tstringstream strBuffer ;                                           \
      strBuffer << p_strMessage ;                                              \
      strMessage = strBuffer.str() ;                                           \
      raiseSomeAlert(__FILE__, __FUNCSIG__, __LINE__, strBuffer.str().c_str()) \
   }                                                                           \
   catch(...){}                                                                \
   {                                                                           \
   }                                                                           \
}                                                                              \
while(false)

bunu kodlamanızı sağlar:

RAISE_ERROR_STL("Hello... The following values " << i << " and " << j << " are wrong") ;

Ve aşağıdaki gibi mesajlar üretebilir:

Error Raised:
====================================
File : MyFile.cpp, line 225
Function : MyFunction(int, double)
Message : "Hello... The following values 23 and 12 are wrong"

Şablonları makrolarla karıştırmanın daha iyi sonuçlara yol açabileceğini unutmayın (örn. Değerleri değişken adlarıyla otomatik olarak yan yana oluşturma)

Diğer durumlarda, örneğin hata ayıklama bilgileri oluşturmak için bazı kodların __FILE__ ve / veya __LINE__ öğelerine ihtiyacınız vardır. Visual C ++ için bir klasik aşağıdadır:

#define WRNG_PRIVATE_STR2(z) #z
#define WRNG_PRIVATE_STR1(x) WRNG_PRIVATE_STR2(x)
#define WRNG __FILE__ "("WRNG_PRIVATE_STR1(__LINE__)") : ------------ : "

Aşağıdaki kodda olduğu gibi:

#pragma message(WRNG "Hello World")

aşağıdaki gibi mesajlar üretir:

C:\my_project\my_cpp_file.cpp (225) : ------------ Hello World

Diğer zamanlarda, bir özellik için alıcılar ve ayarlayıcılar oluşturma gibi # ve ## birleştirme işleçlerini kullanarak kod oluşturmanız gerekir (bu, oldukça sınırlı durumlar içindir).

Diğer zamanlarda, aşağıdaki gibi bir işlevle kullanılırsa derlenmeyecek bir kod üreteceksiniz:

#define MY_TRY      try{
#define MY_CATCH    } catch(...) {
#define MY_END_TRY  }

Hangi olarak kullanılabilir

MY_TRY
   doSomethingDangerous() ;
MY_CATCH
   tryToRecoverEvenWithoutMeaningfullInfo() ;
   damnThoseMacros() ;
MY_END_TRY

(yine de, bu tür kodların sadece bir kez doğru kullanıldığını gördüm )

Son, ama en az değil, ünlü boost::foreach!!!

#include <string>
#include <iostream>
#include <boost/foreach.hpp>

int main()
{
    std::string hello( "Hello, world!" );

    BOOST_FOREACH( char ch, hello )
    {
        std::cout << ch;
    }

    return 0;
}

(Not: kod kopyalama / destek ana sayfasından yapıştırıldı)

Hangisi (IMHO) daha iyi std::for_each.

Bu nedenle, makrolar her zaman yararlıdır çünkü normal derleyici kurallarının dışındadırlar. Ama çoğu zaman bir tane gördüğümde, etkili bir şekilde uygun C ++'a çevrilmemiş C kodunun kalıntıları olduğunu görüyorum.

UnitTest ++ gibi C ++ için birim test çerçeveleri, önişlemci makroları etrafında döner. Birkaç birim test kodu, elle yazılması hiç de eğlenceli olmayacak bir sınıflar hiyerarşisine genişler. UnitTest ++ ve önişlemci büyüsü gibi bir şey olmadan, C ++ için birim testlerini nasıl verimli bir şekilde yazacağınızı bilmiyorum.

C ön işlemcisinden korkmak akkor ampullerden korkmak gibidir, çünkü sadece floresan ampuller alırız. Evet, birincisi {elektrik | programcı zamanı} verimsiz. Evet, onları (tam anlamıyla) yakabilirsiniz. Ama düzgün bir şekilde idare ederseniz işi halledebilirler.

Gömülü sistemleri programladığınızda, form birleştirici arasındaki tek seçenek C'yi kullanır. C ++ ile masaüstünde programlama yaptıktan ve sonra daha küçük, gömülü hedeflere geçtikten sonra, pek çok çıplak C özelliğinin (makrolar dahil) “yetersizlikleri” hakkında endişelenmeyi bırakmayı ve bunlardan alabileceğiniz en iyi ve güvenli kullanımı anlamaya çalışmayı öğrenirsiniz. özellikleri.

Alexander Stepanov diyor :

C ++ 'da programladığımızda C mirasından utanmamalıyız, ama tam olarak kullanmalıyız. C ++ ile ilgili tek problemler ve hatta C ile ilgili tek problemler, kendileri kendi mantıklarıyla tutarlı olmadıklarında ortaya çıkar.

__FILE__Ve __LINE__makroları, QA altyapımızdaki otomatik günlük dosyası tarayıcıları ile birlikte bilgi açısından zengin istisna atma, yakalama ve günlüğe kaydetme işlemlerinde tanı amaçlı kullanırız .

Örneğin, atma makrosu OUR_OWN_THROW, metinsel bir açıklama da dahil olmak üzere istisna türü ve yapıcı parametreleriyle birlikte kullanılabilir. Bunun gibi:

OUR_OWN_THROW(InvalidOperationException, (L"Uninitialized foo!"));

Bu makro elbette InvalidOperationExceptionistisnayı yapıcı parametresi olarak açıklamayla birlikte atar , ancak aynı zamanda atışın gerçekleştiği dosya adı ve satır numarasından ve metin açıklamasından oluşan bir günlük dosyasına bir mesaj yazar. Atılan istisna, aynı zamanda günlüğe kaydedilen bir kimlik alır. Kural dışı durum kodda başka bir yere takılırsa, bu şekilde işaretlenir ve günlük dosyası bu özel kural dışı durumun ele alındığını ve bu nedenle daha sonra kaydedilebilecek herhangi bir kilitlenmenin nedeni olmadığını gösterir. İşlenmeyen istisnalar, otomatik KG altyapımız tarafından kolayca alınabilir.

Kod tekrarı.

Önişlemci kütüphanesini artırmak için bir göz atın , bu bir tür meta-meta-programlama. Konu-> motivasyon konusunda iyi bir örnek bulabilirsiniz.

Bazı çok gelişmiş ve kullanışlı şeyler, şablonlar da dahil olmak üzere c ++ "dil yapılarını" kullanarak asla yapamayacağınız önişlemci (makrolar) kullanılarak oluşturulabilir.

Örnekler:

Hem C tanımlayıcısı hem de dize oluşturma

C enum tipi değişkenlerini dize olarak kullanmanın kolay yolu

Önişlemci Meta Programlamasını Artırın

Bazen makroları kullanırım, böylece bilgileri tek bir yerde tanımlayabilirim, ancak kodun farklı bölümlerinde farklı şekillerde kullanabilirsiniz. Sadece biraz kötü :)

Örneğin, "field_list.h" içinde:

/*
 * List of fields, names and values.
 */
FIELD(EXAMPLE1, "first example", 10)
FIELD(EXAMPLE2, "second example", 96)
FIELD(ANOTHER, "more stuff", 32)
...
#undef FIELD

Daha sonra bir genel numaralandırma için sadece adı kullanmak için tanımlanabilir:

#define FIELD(name, desc, value) FIELD_ ## name,

typedef field_ {

#include "field_list.h"

    FIELD_MAX

} field_en;

Özel bir başlatma işlevinde, tüm alanlar bir tabloyu verilerle doldurmak için kullanılabilir:

#define FIELD(name, desc, value) \
    table[FIELD_ ## name].desc = desc; \
    table[FIELD_ ## name].value = value;

#include "field_list.h"

Yaygın bir kullanım, derleme ortamını algılamaktır, platformlar arası geliştirme için, amaçlarınız için zaten bir çapraz platform kütüphanesi mevcut değilse, linux için bir kod kümesi yazabilir ve Windows için başka bir kod yazabilirsiniz.

Yani, kaba bir örnekte, platformlar arası bir muteks

void lock()
{
    #ifdef WIN32
    EnterCriticalSection(...)
    #endif
    #ifdef POSIX
    pthread_mutex_lock(...)
    #endif
}

İşlevler için, tür güvenliğini açıkça yoksaymak istediğinizde yararlıdır. ASSERT yapmak için yukarıdaki ve aşağıdaki birçok örnek gibi. Tabii ki, birçok C / C ++ özelliği gibi kendinizi ayağınızdan çekebilirsiniz, ancak dil size araçları sağlar ve ne yapacağınıza karar vermenizi sağlar.

Gibi bir şey

void debugAssert(bool val, const char* file, int lineNumber);
#define assert(x) debugAssert(x,__FILE__,__LINE__);

Böylece sadece

assert(n == true);

ve n yanlışsa günlüğünüze yazdırılan sorunun kaynak dosya adını ve satır numarasını alın.

Normal bir işlev kullanıyorsanız,

void assert(bool val);

makro yerine, elde edebileceğiniz tek şey, daha az kullanışlı olacak günlüğe yazdırılan onaylama işlevinizin satır numarasıdır.

#define ARRAY_SIZE(arr) (sizeof arr / sizeof arr[0])

Geçerli bir iş parçacığında tartışılan 'tercih edilen' şablon çözümünün aksine, bunu sabit bir ifade olarak kullanabilirsiniz:

char src[23];
int dest[ARRAY_SIZE(src)];

Hata ayıklama ve birim sınama senaryolarına yardımcı olması için #defines kullanabilirsiniz. Örneğin, bellek işlevlerinin özel günlük varyantlarını oluşturun ve özel bir memlog_preinclude.h oluşturun:

#define malloc memlog_malloc
#define calloc memlog calloc
#define free memlog_free

Kodunuzu kullanarak derleyin:

gcc -Imemlog_preinclude.h ...

Memlog.o dosyasındaki son resme bir bağlantı. Artık malloc, vb., Belki de günlük kaydı amacıyla veya birim testleri için ayırma hatalarını simüle etmek için kontrol ediyorsunuz.

Derleme zamanında Derleyici / OS / Donanım özel davranış üzerinde karar verirken.

Comppiler / OS / Donanım spesifik özelliklerine arayüz yapmanızı sağlar.

#if defined(MY_OS1) && defined(MY_HARDWARE1)
#define   MY_ACTION(a,b,c)      doSothing_OS1HW1(a,b,c);}
#elif define(MY_OS1) && defined(MY_HARDWARE2)
#define   MY_ACTION(a,b,c)      doSomthing_OS1HW2(a,b,c);}
#elif define(MY_SUPER_OS)
          /* On this hardware it is a null operation */
#define   MY_ACTION(a,b,c)
#else
#error  "PLEASE DEFINE MY_ACTION() for this Compiler/OS/HArdware configuration"
#endif

İstisnaları kolayca tanımlamak için makroları kullanıyorum:

DEF_EXCEPTION(RessourceNotFound, "Ressource not found")

burada DEF_EXCEPTION

#define DEF_EXCEPTION(A, B) class A : public exception\
  {\
  public:\
    virtual const char* what() const throw()\
    {\
      return B;\
    };\
  }\

Derleyiciler satır içi isteğinizi reddedebilir.

Makrolar her zaman yerlerini alacaktır.

Yararlı bulduğum bir şey #define hata ayıklama izleme için DEBUG - bir hata ayıklama sırasında 1 bırakabilir (hatta tüm geliştirme döngüsü boyunca açık bırakabilirsiniz) ve sonra gemi zamanı geldiğinde kapatın.

Son işimde bir virüs tarayıcı üzerinde çalışıyordum. Benim hata ayıklamak için bir şey kolaylaştırmak için, her yerde sıkışmış çok sayıda günlük vardı, ama böyle bir yüksek talep app, bir fonksiyon çağrısı masrafı çok pahalı. Bu yüzden, bu küçük Makro ile geldim, bu hala bir müşteri sitesinde bir yayın sürümünde hata ayıklama günlüğünü etkinleştirmeme izin verdi, bir işlev çağrısı maliyeti olmadan hata ayıklama bayrağını kontrol edip hiçbir şey kaydetmeden geri dönecekti veya etkinleştirilmişse , günlüğe kaydetmeyi yapar ... Makro aşağıdaki gibi tanımlanmıştır:

#define dbgmsg(_FORMAT, ...)  if((debugmsg_flag  & 0x00000001) || (debugmsg_flag & 0x80000000))     { log_dbgmsg(_FORMAT, __VA_ARGS__);  }

Günlük işlevlerindeki VA_ARGS nedeniyle, bu gibi bir makro için iyi bir durumdu.

Bundan önce, yüksek güvenlikli bir uygulamada, kullanıcıya doğru erişime sahip olmadıklarını söylemek için gereken bir makro kullandım ve onlara hangi bayrağa ihtiyaç duyduklarını söyleyecekti.

Şu şekilde tanımlanan Makrolar:

#define SECURITY_CHECK(lRequiredSecRoles) if(!DoSecurityCheck(lRequiredSecRoles, #lRequiredSecRoles, true)) return
#define SECURITY_CHECK_QUIET(lRequiredSecRoles) (DoSecurityCheck(lRequiredSecRoles, #lRequiredSecRoles, false))

Ardından, kontrolleri kullanıcı arayüzünün her yerine serpiştirebiliriz ve bu rolünüz yoksa, hangi rollerin yapmaya çalıştığınız eylemi gerçekleştirmesine izin verildiğini söyleyebiliriz. İkisinin nedeni bazı yerlerde bir değer döndürmek ve diğerlerinde geçersiz bir işlevden geri dönmekti ...

SECURITY_CHECK(ROLE_BUSINESS_INFORMATION_STEWARD | ROLE_WORKER_ADMINISTRATOR);

LRESULT CAddPerson1::OnWizardNext() 
{
   if(m_Role.GetItemData(m_Role.GetCurSel()) == parent->ROLE_EMPLOYEE) {
      SECURITY_CHECK(ROLE_WORKER_ADMINISTRATOR | ROLE_BUSINESS_INFORMATION_STEWARD ) -1;
   } else if(m_Role.GetItemData(m_Role.GetCurSel()) == parent->ROLE_CONTINGENT) {
      SECURITY_CHECK(ROLE_CONTINGENT_WORKER_ADMINISTRATOR | ROLE_BUSINESS_INFORMATION_STEWARD | ROLE_WORKER_ADMINISTRATOR) -1;
   }
...

Her neyse, bu şekilde kullandım ve şablonlarla nasıl yardımcı olabileceğinden emin değilim ... Bunun dışında, GERÇEKTEN gerekli olmadıkça bunlardan kaçınmaya çalışıyorum.

Yine başka bir foreach makrosu. T: tip, c: konteyner, ben: yineleyici

#define foreach(T, c, i) for(T::iterator i=(c).begin(); i!=(c).end(); ++i)
#define foreach_const(T, c, i) for(T::const_iterator i=(c).begin(); i!=(c).end(); ++i)

Kullanım (konsept gösteren, gerçek değil):

void MultiplyEveryElementInList(std::list<int>& ints, int mul)
{
    foreach(std::list<int>, ints, i)
        (*i) *= mul;
}

int GetSumOfList(const std::list<int>& ints)
{
    int ret = 0;
    foreach_const(std::list<int>, ints, i)
        ret += *i;
    return ret;
}

Daha iyi uygulamalar mevcut: Google "BOOST_FOREACH"

İyi makaleler mevcut: Koşullu Sevgi: FOREACH Redux (Eric Niebler) http://www.artima.com/cppsource/foreach.html

Belki de makroların en büyük kullanımı platformdan bağımsız gelişmedir. Tür tutarsızlığı durumlarını düşünün - makrolarla, yalnızca farklı başlık dosyalarını kullanabilirsiniz: --WIN_TYPES.H

typedef ...some struct

--POSIX_TYPES.h

typedef ...some another struct

--program.h

#ifdef WIN32
#define TYPES_H "WINTYPES.H"
#else 
#define TYPES_H "POSIX_TYPES.H"
#endif

#include TYPES_H

Bence başka şekillerde uygulamaktan çok okunabilir.

Görünüşe göre VA_ARGS sadece dolaylı olarak bahsedildi:

Genel C ++ 03 kodu yazarken değişken sayıda (genel) parametreye ihtiyacınız varsa, şablon yerine makro kullanabilirsiniz.

#define CALL_RETURN_WRAPPER(FnType, FName, ...)          \
  if( FnType theFunction = get_op_from_name(FName) ) {   \
    return theFunction(__VA_ARGS__);                     \
  } else {                                               \
    throw invalid_function_name(FName);                  \
  }                                                      \
/**/

_{Not: Genel olarak, ad kontrolü / atımı varsayımsal get_op_from_namefonksiyona dahil edilebilir . Bu sadece bir örnek. VA_ARGS çağrısını çevreleyen başka bir genel kod olabilir.}

C ++ 11 ile varyasyonlu şablonlar elde ettikten sonra, bunu "düzgün" bir şablonla çözebiliriz.

Bu hile önişlemci bir işlevi ile taklit edilemez akıllı bir kullanım olduğunu düşünüyorum:

#define COMMENT COMMENT_SLASH(/)
#define COMMENT_SLASH(s) /##s

#if defined _DEBUG
#define DEBUG_ONLY
#else
#define DEBUG_ONLY COMMENT
#endif

O zaman bu şekilde kullanabilirsiniz:

cout <<"Hello, World!" <<endl;
DEBUG_ONLY cout <<"This is outputed only in debug mode" <<endl;

Ayrıca bir RELEASE_ONLY makrosu tanımlayabilirsiniz.

Veya seçeneğini #definekullanarak derleyici komut satırındaki sabitleri kullanabilirsiniz . Bu, genellikle aynı yazılımı birden çok platform için çapraz derlerken yararlıdır, çünkü dosyalarınızın her platform için hangi sabitlerin tanımlandığını kontrol etmesini sağlayabilirsiniz.-D/D