SafeInt Sınıfı

Tamsayı taşmasını önlemeye yardımcı olmak için tamsayı temel öğelerini genişletir ve farklı tamsayı türlerini karşılaştırmanıza olanak tanır.

Not

SafeInt kitaplığının en son sürümü konumundadır https://github.com/dcleblanc/SafeInt. SafeInt kitaplığını kullanmak için depoyu kopyalayın ve #include "SafeInt.hpp"

Sözdizimi

template<typename T, typename E = _SAFEINT_DEFAULT_ERROR_POLICY>
class SafeInt;

Parametreler

T
Yerini alan tamsayı veya Boole parametresinin SafeInt türü.

E
Hata işleme ilkesini tanımlayan numaralandırılmış veri türü.

U
İkincil işlenen için tamsayı veya Boole parametresinin türü.

Rhs
[in] Birkaç bağımsız işlevde işlecin sağ tarafındaki değeri temsil eden bir giriş parametresi.

ben
[in] Birkaç bağımsız işlevde işlecin sağ tarafındaki değeri temsil eden bir giriş parametresi.

Bit
[in] Birkaç bağımsız işlevde işlecin sağ tarafındaki değeri temsil eden bir giriş parametresi.

Üyeler

Ortak Oluşturucular

Veri Akışı Adı	Açıklama
SafeInt::SafeInt	Varsayılan oluşturucu.

Atama İşleçleri

Veri Akışı Adı	Sözdizimi
=	`template<typename U>` `SafeInt<T,E>& operator= (const U& rhs)`
=	`SafeInt<T,E>& operator= (const T& rhs) throw()`
=	`template<typename U>` `SafeInt<T,E>& operator= (const SafeInt<U, E>& rhs)`
=	`SafeInt<T,E>& operator= (const SafeInt<T,E>& rhs) throw()`

Atama İşleçleri

Veri Akışı Adı	Sözdizimi
ikili	`operator bool() throw()`
char	`operator char() const`
imzalı karakter	`operator signed char() const`
unsigned char	`operator unsigned char() const`
__int16	`operator __int16() const`
imzasız __int16	`operator unsigned __int16() const`
__int32	`operator __int32() const`
imzasız __int32	`operator unsigned __int32() const`
uzun	`operator long() const`
imzasız long	`operator unsigned long() const`
__int64	`operator __int64() const`
imzasız __int64	`operator unsigned __int64() const`
wchar_t	`operator wchar_t() const`

Karşılaştırma İşleçleri

Veri Akışı Adı	Sözdizimi
<	`template<typename U>` `bool operator< (U rhs) const throw()`
<	`bool operator< (SafeInt<T,E> rhs) const throw()`
>=	`template<typename U>` `bool operator>= (U rhs) const throw()`
>=	`Bool operator>= (SafeInt<T,E> rhs) const throw()`
>	`template<typename U>` `bool operator> (U rhs) const throw()`
>	`Bool operator> (SafeInt<T,E> rhs) const throw()`
<=	`template<typename U>` `bool operator<= (U rhs) const throw()`
<=	`bool operator<= (SafeInt<T,E> rhs) const throw()`
==	`template<typename U>` `bool operator== (U rhs) const throw()`
==	`bool operator== (bool rhs) const throw()`
==	`bool operator== (SafeInt<T,E> rhs) const throw()`
!=	`template<typename U>` `bool operator!= (U rhs) const throw()`
!=	`bool operator!= (bool b) const throw()`
!=	`bool operator!= (SafeInt<T,E> rhs) const throw()`

Aritmetik İşleçler

Veri Akışı Adı	Sözdizimi
+	`const SafeInt<T,E>& operator+ () const throw()`
-	`SafeInt<T,E> operator- () const`
++	`SafeInt<T,E>& operator++ ()`
--	`SafeInt<T,E>& operator-- ()`
%	`template<typename U>` `SafeInt<T,E> operator% (U rhs) const`
%	`SafeInt<T,E> operator% (SafeInt<T,E> rhs) const`
%=	`template<typename U>` `SafeInt<T,E>& operator%= (U rhs)`
%=	`template<typename U>` `SafeInt<T,E>& operator%= (SafeInt<U, E> rhs)`
*	`template<typename U>` `SafeInt<T,E> operator* (U rhs) const`
*	`SafeInt<T,E> operator* (SafeInt<T,E> rhs) const`
*=	`SafeInt<T,E>& operator*= (SafeInt<T,E> rhs)`
*=	`template<typename U>` `SafeInt<T,E>& operator*= (U rhs)`
*=	`template<typename U>` `SafeInt<T,E>& operator*= (SafeInt<U, E> rhs)`
/	`template<typename U>` `SafeInt<T,E> operator/ (U rhs) const`
/	`SafeInt<T,E> operator/ (SafeInt<T,E> rhs ) const`
/=	`SafeInt<T,E>& operator/= (SafeInt<T,E> i)`
/=	`template<typename U>` `SafeInt<T,E>& operator/= (U i)`
/=	`template<typename U>` `SafeInt<T,E>& operator/= (SafeInt<U, E> i)`
+	`SafeInt<T,E> operator+ (SafeInt<T,E> rhs) const`
+	`template<typename U>` `SafeInt<T,E> operator+ (U rhs) const`
+=	`SafeInt<T,E>& operator+= (SafeInt<T,E> rhs)`
+=	`template<typename U>` `SafeInt<T,E>& operator+= (U rhs)`
+=	`template<typename U>` `SafeInt<T,E>& operator+= (SafeInt<U, E> rhs)`
-	`template<typename U>` `SafeInt<T,E> operator- (U rhs) const`
-	`SafeInt<T,E> operator- (SafeInt<T,E> rhs) const`
-=	`SafeInt<T,E>& operator-= (SafeInt<T,E> rhs)`
-=	`template<typename U>` `SafeInt<T,E>& operator-= (U rhs)`
-=	`template<typename U>` `SafeInt<T,E>& operator-= (SafeInt<U, E> rhs)`

Mantıksal İşleçler

Veri Akışı Adı	Sözdizimi
!	`bool operator !() const throw()`
~	`SafeInt<T,E> operator~ () const throw()`
<<	`template<typename U>` `SafeInt<T,E> operator<< (U bits) const throw()`
<<	`template<typename U>` `SafeInt<T,E> operator<< (SafeInt<U, E> bits) const throw()`
<<=	`template<typename U>` `SafeInt<T,E>& operator<<= (U bits) throw()`
<<=	`template<typename U>` `SafeInt<T,E>& operator<<= (SafeInt<U, E> bits) throw()`
>>	`template<typename U>` `SafeInt<T,E> operator>> (U bits) const throw()`
>>	`template<typename U>` `SafeInt<T,E> operator>> (SafeInt<U, E> bits) const throw()`
>>=	`template<typename U>` `SafeInt<T,E>& operator>>= (U bits) throw()`
>>=	`template<typename U>` `SafeInt<T,E>& operator>>= (SafeInt<U, E> bits) throw()`
&	`SafeInt<T,E> operator& (SafeInt<T,E> rhs) const throw()`
&	`template<typename U>` `SafeInt<T,E> operator& (U rhs) const throw()`
&=	`SafeInt<T,E>& operator&= (SafeInt<T,E> rhs) throw()`
&=	`template<typename U>` `SafeInt<T,E>& operator&= (U rhs) throw()`
&=	`template<typename U>` `SafeInt<T,E>& operator&= (SafeInt<U, E> rhs) throw()`
^	`SafeInt<T,E> operator^ (SafeInt<T,E> rhs) const throw()`
^	`template<typename U>` `SafeInt<T,E> operator^ (U rhs) const throw()`
^=	`SafeInt<T,E>& operator^= (SafeInt<T,E> rhs) throw()`
^=	`template<typename U>` `SafeInt<T,E>& operator^= (U rhs) throw()`
^=	`template<typename U>` `SafeInt<T,E>& operator^= (SafeInt<U, E> rhs) throw()`
\|	`SafeInt<T,E> operator\| (SafeInt<T,E> rhs) const throw()`
\|	`template<typename U>` `SafeInt<T,E> operator\| (U rhs) const throw()`
\|=	`SafeInt<T,E>& operator\|= (SafeInt<T,E> rhs) throw()`
\|=	`template<typename U>` `SafeInt<T,E>& operator\|= (U rhs) throw()`
\|=	`template<typename U>` `SafeInt<T,E>& operator\|= (SafeInt<U, E> rhs) throw()`

Açıklamalar

sınıfı, SafeInt matematik işlemlerinde tamsayı taşmasına karşı koruma sağlar. Örneğin, iki 8 bit tamsayı eklemeyi göz önünde bulundurun: birinin değeri 200, ikincisinin değeri 100'tür. Doğru matematik işlemi 200 + 100 = 300 olacaktır. Ancak, 8 bit tamsayı sınırı nedeniyle üst bit kaybolur ve derleyici sonuç olarak 44 (300 - 2⁸) döndürür. Bu matematiksel denkleme bağlı olan herhangi bir işlem beklenmeyen davranışlar oluşturur.

sınıfı SafeInt , aritmetik taşma olup olmadığını veya kodun sıfıra bölmeye çalışıp çalışmadığını denetler. Her iki durumda da sınıfı, programı olası sorun konusunda uyarmak için hata işleyicisini çağırır.

Bu sınıf, nesne oldukları SafeInt sürece iki farklı tamsayı türünü karşılaştırmanıza da olanak tanır. Genellikle, bir karşılaştırma yaptığınızda, önce sayıları aynı türde olacak şekilde dönüştürmeniz gerekir. Bir sayıyı başka bir türe atama, genellikle veri kaybı olmadığından emin olmak için denetimler gerektirir.

Bu konudaki operators tablosunda sınıfı tarafından SafeInt desteklenen matematik ve karşılaştırma işleçleri listelenir. Çoğu matematik işleci türünde Tbir SafeInt nesnesi döndürür.

ile SafeInt tamser türü arasındaki karşılaştırma işlemleri her iki yönde de gerçekleştirilebilir. Örneğin, hem hem y> SafeInt<int>(x) de SafeInt<int>(x) < y geçerlidir ve aynı sonucu döndürür.

Birçok ikili işleç, iki farklı SafeInt türün kullanılmasını desteklemez. Bunun bir örneği işlecidir & . SafeInt<T, E> & int desteklenir ancak SafeInt<T, E> & SafeInt<U, E> desteklenmez. İkinci örnekte, derleyici döndürülecek parametre türünü bilmiyor. Bu sorunun bir çözümü, ikinci parametreyi temel türe geri döndürmektir. Aynı parametreler kullanılarak, bu ile SafeInt<T, E> & (U)SafeInt<U, E>yapılabilir.

Not

Bit tabanlı işlemler için iki farklı parametre aynı boyutta olmalıdır. Boyutlar farklıysa, derleyici bir ASSERT özel durumu oluşturur. Bu işlemin sonuçlarının doğru olduğu garanti edilemiyor. Bu sorunu çözmek için, daha büyük parametreyle aynı boyuta gelene kadar daha küçük parametreyi yayınlayın.

Vardiya işleçleri için şablon türü için var olandan daha fazla bit kaydırmak assert özel durumu oluşturur. Bunun sürüm modunda hiçbir etkisi olmayacaktır. Dönüş türü özgün türle aynı olduğundan shift işleçleri için iki tür SafeInt parametresinin karıştırılması mümkündür. İşlecin sağ tarafındaki sayı yalnızca kaydıracak bit sayısını gösterir.

SafeInt nesnesiyle mantıksal bir karşılaştırma yaptığınızda, karşılaştırma kesinlikle aritmetiktir. Örneğin, şu ifadeleri göz önünde bulundurun:

SafeInt<uint>((uint)~0) > -1
((uint)~0) > -1

İlk deyim olarak trueçözümlense de, ikinci deyim olarak falseçözülür. 0'ın bit düzeyinde olumsuzlaması 0xFFFFFFFF. İkinci deyimde, varsayılan karşılaştırma işleci 0xFFFFFFFF 0xFFFFFFFF ile karşılaştırır ve bunların eşit olduğunu kabul eder. sınıfı için SafeInt karşılaştırma işleci, ikinci parametrenin negatif olduğunu, ilk parametre ise işaretsiz olduğunu fark eder. Bu nedenle, bit gösterimi aynı olsa da mantıksal SafeInt işleç işaretsiz tamsayının -1'den büyük olduğunu fark eder.

sınıfını SafeInt üçüncül işleçle ?: birlikte kullanırken dikkatli olun. Aşağıdaki kod satırını göz önünde bulundurun.

Int x = flag ? SafeInt<unsigned int>(y) : -1;

Derleyici bunu şu şekilde dönüştürür:

Int x = flag ? SafeInt<unsigned int>(y) : SafeInt<unsigned int>(-1);

ise flag false, derleyici -1 xdeğerini öğesine atamak yerine bir özel durum oluşturur. Bu nedenle, bu davranışı önlemek için kullanılacak doğru kod aşağıdaki satırdır.

Int x = flag ? (int) SafeInt<unsigned int>(y) : -1;

T ve U bir Boole türü, karakter türü veya tamsayı türü atanabilir. Tamsayı türleri imzalanabilir veya işaretsiz olabilir ve 8 bit ile 64 bit arasında herhangi bir boyuta sahip olabilir.

Not

sınıfı herhangi bir tamsayı türünü kabul etse SafeInt de, imzasız türlerle daha verimli bir şekilde performans gösterir.

E , kullanan hata işleme mekanizmasıdır SafeInt . SafeInt kitaplığıyla iki hata işleme mekanizması sağlanır. Varsayılan ilke, SafeIntErrorPolicy_SafeIntExceptionbir hata oluştuğunda SafeIntException Sınıfı özel durumu oluşturan ilkesidir. Diğer ilke, SafeIntErrorPolicy_InvalidParameterbir hata oluşursa programı durduran ilkesidir.

Hata ilkesini özelleştirmek için iki seçenek vardır. İlk seçenek, bir SafeIntoluştururken parametresini E ayarlamaktır. Yalnızca bir SafeIntiçin hata işleme ilkesini değiştirmek istediğinizde bu seçeneği kullanın. Diğer seçenek, kitaplığı eklemeden önce özelleştirilmiş hata işleme sınıfınız olacak _SAFEINT_DEFAULT_ERROR_POLICY tanımlamaktır SafeInt . Kodunuzda sınıfın tüm örnekleri SafeInt için varsayılan hata işleme ilkesini değiştirmek istediğinizde bu seçeneği kullanın.

Not

SafeInt kitaplığındaki hataları işleyen özelleştirilmiş bir sınıf, hata işleyicisini çağıran koda denetim döndürmemelidir. Hata işleyici çağrıldıktan sonra işlemin sonucuna SafeInt güvenilemiyor.

Devralma Hiyerarşisi

SafeInt

Gereksinimler

Üst bilgi: SafeInt.hpp

Not

Bu kitaplığın en son sürümü konumundadır https://github.com/dcleblanc/SafeInt. Kitaplığı klonlayın ve SafeInt kitaplığını kullanmak için SafeInt.hpp dosyasını ekleyin. Bu GitHub deposunu safeint.h> olarak <tercih edin. safeint.h> dosyasının <az sayıda hata düzeltmesi içeren, C++'ın daha verimli kodlara neden olan modern özelliklerini kullanan ve gcc, clang veya Intel derleyicileri kullanılarak herhangi bir platforma taşınabilir modern bir sürümüdür.

Örnek

#include "SafeInt.hpp" // set path to your clone of the SafeInt GitHub repo (https://github.com/dcleblanc/SafeInt)

int main()
{
    int divisor = 3;
    int dividend = 6;
    int result;

    bool success = SafeDivide(dividend, divisor, result); // result = 2
    success = SafeDivide(dividend, 0, result); // expect fail. result isn't modified.
}

Ad alanı: hiçbiri

SafeInt::SafeInt

Bir SafeInt nesne oluşturur.

SafeInt() throw

SafeInt (const T& i) throw ()

SafeInt (bool b) throw ()

template <typename U>
SafeInt (const SafeInt <U, E>& u)

I template <typename U>
SafeInt (const U& i)

Parametreler

i
[in] Yeni SafeInt nesnenin değeri. Bu, oluşturucuya bağlı olarak T veya U türünde bir parametre olmalıdır.

b
[in] Yeni SafeInt nesnenin Boole değeri.

u
[in] SafeInt U türünde bir Yeni SafeInt nesne u ile aynı değere sahip olur, ancak T türünde olur.

U içinde SafeIntdepolanan veri türü. Bu bir Boole, karakter veya tamsayı türü olabilir. Tamsayı türündeyse, imzalı veya imzasız olabilir ve 8 ile 64 bit arasında olabilir.

Açıklamalar

i veya u oluşturucusunun giriş parametresi boole, karakter veya tamsayı türünde olmalıdır. Başka bir parametre türüyse, SafeInt sınıfı geçersiz bir giriş parametresini belirtmek için static_assert çağırır.

Şablon türünü U kullanan oluşturucular, giriş parametresini tarafından Tbelirtilen türe otomatik olarak dönüştürür. sınıfı, SafeInt veri kaybı olmadan verileri dönüştürür. Verileri veri kaybı olmadan türe T dönüştüremiyorsa hata işleyicisine E bildirir.

Boole parametresinden bir SafeInt oluşturursanız, değeri hemen başlatmanız gerekir. kodunu SafeInt<bool> sb;kullanarak oluşturamazsınızSafeInt. Bu bir derleme hatası oluşturur.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-11-07

Aracılığıyla paylaş

SafeInt Sınıfı

Sözdizimi

Parametreler

Üyeler

Ortak Oluşturucular

Atama İşleçleri

Atama İşleçleri

Karşılaştırma İşleçleri

Aritmetik İşleçler

Mantıksal İşleçler

Açıklamalar

Devralma Hiyerarşisi

Gereksinimler

Örnek

SafeInt::SafeInt

Parametreler

Açıklamalar

Geri Bildirim

Ek kaynaklar