nilai maksimum int

Apakah ada kode untuk menemukan nilai maksimum integer (sesuai dengan kompiler) di Integer.MaxValuefungsi seperti C / C ++ di java?

Dalam C ++:

#include <limits>

lalu gunakan

int imin = std::numeric_limits<int>::min(); // minimum value
int imax = std::numeric_limits<int>::max();

std::numeric_limits adalah tipe templat yang dapat dipakai dengan jenis lain:

float fmin = std::numeric_limits<float>::min(); // minimum positive value
float fmax = std::numeric_limits<float>::max();

Dalam C:

#include <limits.h>

lalu gunakan

int imin = INT_MIN; // minimum value
int imax = INT_MAX;

atau

#include <float.h>

float fmin = FLT_MIN;  // minimum positive value
double dmin = DBL_MIN; // minimum positive value

float fmax = FLT_MAX;
double dmax = DBL_MAX;

Saya tahu ini pertanyaan lama tapi mungkin seseorang dapat menggunakan solusi ini:

int size = 0; // Fill all bits with zero (0)
size = ~size; // Negate all bits, thus all bits are set to one (1)

Sejauh ini kita memiliki -1 sebagai hasilnya sampai ukuran adalah int yang ditandatangani.

size = (unsigned int)size >> 1; // Shift the bits of size one position to the right.

Seperti yang dikatakan Standard, bit yang digeser adalah 1 jika variabel ditandatangani dan negatif dan 0 jika variabel tidak ditandatangani atau ditandatangani dan positif.

Karena ukuran masuk dan negatif, kami akan menggeser bit masuk yang 1, yang tidak banyak membantu, jadi kami menggunakan int unsigned, memaksa untuk menggeser dalam 0 sebagai gantinya, mengatur bit tanda ke 0 sambil membiarkan semua bit lainnya tetap 1.

cout << size << endl; // Prints out size which is now set to maximum positive value.

Kita juga bisa menggunakan mask dan xor tetapi kemudian kita harus tahu bitsize variabel yang tepat. Dengan menggeser bit di depan, kita tidak perlu tahu kapan saja berapa banyak bit yang dimiliki int pada mesin atau kompiler atau kita tidak perlu menyertakan perpustakaan tambahan.

#include <climits>
#include <iostream>
using namespace std;

int main() {
  cout << INT_MAX << endl;
}

Berikut ini adalah makro yang saya gunakan untuk mendapatkan nilai maksimum untuk bilangan bulat yang ditandatangani, yang tidak tergantung pada ukuran jenis bilangan bulat yang ditandatangani yang digunakan, dan yang gcc -Woverflow tidak akan mengeluh

#define SIGNED_MAX(x) (~(-1 << (sizeof(x) * 8 - 1)))

int a = SIGNED_MAX(a);
long b = SIGNED_MAX(b);
char c = SIGNED_MAX(c); /* if char is signed for this target */
short d = SIGNED_MAX(d);
long long e = SIGNED_MAX(e);

Mengapa tidak menulis kode seperti:

int  max_neg = ~(1 << 31);
int  all_ones = -1;
int max_pos = all_ones & max_neg;

OK Saya tidak punya tanggapan untuk mengomentari jawaban sebelumnya (dari Philippe De Muyter) atau menaikkan skornya, maka contoh baru menggunakan definisinya untuk SIGNED_MAX yang secara sepele diperluas untuk jenis yang tidak ditandatangani:

// We can use it to define limits based on actual compiler built-in types also: 
#define INT_MAX   SIGNED_MAX(int)
// based on the above, we can extend it for unsigned types also:
#define UNSIGNED_MAX(x) (  (SIGNED_MAX(x)<<1) | 1 ) // We reuse SIGNED_MAX
#define UINT_MAX  UNSIGNED_MAX(unsigned int) // on ARM: 4294967295
// then we can have:
unsigned int width = UINT_MAX;

Tidak seperti menggunakan header ini atau itu, di sini kita menggunakan tipe asli dari kompiler.

#include <iostrema>

int main(){
    int32_t maxSigned = -1U >> 1;
    cout << maxSigned << '\n';
    return 0;
}

Mungkin bergantung pada arsitektur tetapi berfungsi setidaknya di setup saya.

Untuk nilai maksimum spesifik int , saya biasanya menulis notasi heksadesimal:

int my_max_int = 0x7fffffff;

alih-alih nilai desimal tidak teratur:

int my_max_int = 2147483647;

Bagaimana dengan (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2)). Ini sama dengan 2^(8*sizeof(int)-2) - 1 + 2^(8*sizeof(int)-2).

Jika sizeof(int) = 4 => 2^(8*4-2) - 1 + 2^(8*4-2) = 2^30 - 1 + 20^30 = (2^32)/2 - 1 [max signed int of 4 bytes].

Anda tidak dapat menggunakan 2*(1 << (8*sizeof(int)-2)) - 1karena itu akan meluap, tetapi (1 << (8*sizeof(int)-2)) - 1 + (1 << (8*sizeof(int)-2))berfungsi.