A manifest constant (a macro) exists in C99 and it is called `SIZE_MAX`. There&#39;s no such constant in C89/90 though.

However, what you have in your original post is a perfectly portable method of finding the maximum value of `size_t`. It is guaranteed to work with any unsigned type.

    #define MAZ_SZ (~(size_t)0)

or `SIZE_MAX`

As an alternative to bit-operations suggested in the other answers, you could do this in C++ 

    #include &lt;limits&gt;
    size_t maxvalue = std::numeric_limits&lt;size_t&gt;::max()

The `size_t max_size = (size_t)-1;` solution suggested by the OP is definitely the best so far, but I did figure out another, more convoluted, way to do this. I&#39;m posting it just for academic curiosity.

    #include &lt;limits.h&gt;

    size_t max_size = ((((size_t)1 &lt;&lt; (CHAR_BIT * sizeof(size_t) - 1)) - 1) &lt;&lt; 1) + 1;



If you are assuming at least C++11 compiler then SIZE_MAX should be available to you:

http://en.cppreference.com/w/c/types/limits

Has anyone tried to use [`gold`](http://en.wikipedia.org/wiki/Gold_%28linker%29) instead of `ld`?

`gold` [promises](http://www.airs.com/blog/archives/38) to be much faster than `ld`, so it may help speeding up test cycles for large C++ applications, but can it be used as drop-in replacement for ld?

Can `gcc`/`g++` directly call `gold`.?

Are there any know bugs or problems?

Although `gold` is part of the GNU binutils since a while, I have found almost no &quot;success stories&quot; or even &quot;Howtos&quot; in the Web.

(*Update: added links to gold and blog entry explaining it*)

Replacing ld with gold - any experience?

Is there a way to run shell commands without output buffering?

For example, `hexdump file | ./my_script` will only pass input from hexdump to my_script in buffered chunks, not line by line.

Actually I want to know a general solution how to make any command unbuffered?

How to make output of any shell command unbuffered?

I&#39;d like to know the maximum value of size_t on the system my program is running.
My first instinct was to use negative 1, like so:

    size_t max_size = (size_t)-1;

But I&#39;m guessing there&#39;s a better way, or a constant defined somewhere.


What is a portable method to find the maximum value of size_t?

I'd like to know the maximum value of size_t on the system my program is running.
My first instinct was to use negative 1, like so:
<pre><code class="hljs language-ini">size_t max_size = (size_t)-1;
</code></pre>
But I'm guessing there's a better way, or a constant defined somewhere.

I was just reading some code and found that the person was using `arr[-2]` to access the 2nd element before the `arr`, like so:

    |a|b|c|d|e|f|g|
           ^------------ arr[0]
             ^---------- arr[1]
       ^---------------- arr[-2]

Is that allowed?

I know that `arr[x]` is the same as `*(arr + x)`. So `arr[-2]` is `*(arr - 2)`, which seems OK. What do you think?


Are negative array indexes allowed in C?

I need to set up a cron job that runs an executable compiled using gcc once every hour.

I logged in as root and typed `crontab -e`

Then I entered the following and saved the file.

    0 * * * *  /path_to_executable

However, the cron job does not work.

I see that when I type `/...path_to_executable` I get a segmentation fault.
I can only execute the executable from the folder it is located in.
Is there a way I can solve this problem?

How to set up a cron job to run an executable every hour?

Can anyone explain how `malloc()` works internally?

I have sometimes done `strace program` and I see a lot of `sbrk` system calls, doing `man sbrk` talks about it being used in `malloc()` but not much more.

How is malloc() implemented internally?

I don&#39;t quite understand how things should be separated in C&#39;s source and header files. I often see many projects with two sets of files with the same name (an extension denotes a source and another donates a header file).

So far, from this lack of understanding, when I&#39;ve written libraries, I&#39;ve chucked all the class and class method code into one file, with indecision as to choosing the file extension.

What should be in headers and what should be in the source files? How do I implement this separation?

What is the fundamental difference between source and header files in C?

What are the differences between `size_t` and `std::size_t` in terms of where they are declared, when they should be used and any other differentiating features?

Difference between size_t and std::size_t

Bjarne Stroustrup wrote in The C++ Programming Language:

&gt; The unsigned integer types are ideal for uses that treat storage as a
&gt; bit array. Using an unsigned instead of an int to gain one more bit to
&gt; represent positive integers is almost never a good idea. Attempts to
&gt; ensure that some values are positive by declaring variables unsigned
&gt; will typically be defeated by the implicit conversion rules.

**size_t** seems to be unsigned &quot;to gain one more bit to represent positive integers&quot;. So was this a mistake (or trade-off), and if so, should we minimize use of it in our own code?

Another relevant article by Scott Meyers is [here][1]. To summarize, he recommends not using unsigned in interfaces, regardless of whether the value is always positive or not. In other words, **even if negative values make no sense, you shouldn&#39;t necessarily use unsigned.**


  [1]: http://www.aristeia.com/Papers/C++ReportColumns/sep95.pdf

Why is size_t unsigned?

At my code, I do not use int or unsigned int. I only use size_t or ssize_t  for portable. For example:

    typedef size_t intc;    // (instead of unsigned int)
    typedef ssize_t uintc;  // (instead of int)

Because `strlen`, `string`, `vector`... all use `size_t`, so I usually use `size_t`. And I only use `ssize_t` when it may be negative.

But I find that:
&gt;    The unsigned integer types are ideal for uses that treat storage as a bit array. 
    Using an unsigned instead of an int to gain one more bit to represent positive integers is almost never a good idea. 
    Attempts to ensure that some values are positive by declaring variables unsigned will typically be defeated by the implicit conversion rules.

in the book [The C++ Programming Language](http://www.amazon.com/dp/0321563840).

So I am puzzled. Am I wrong? Why does the STL not abide by the suggest on the book?


should use size_t or ssize_t

My question is that

I have a size_t data, but now I want to convert it to double or int.

If I do something like 

     size_t data = 99999999;
     int convertdata = data;

the compiler will report warning. because it maybe overflow.

Do you have some method like the boost or some other method to do the convert?


How to cast the size_t to double or int C++

I&#39;m under the same impression as [this answer](https://stackoverflow.com/a/9387041/584518), that `size_t` is always guaranteed by the standard to be large enough to hold the largest possible type of a given system.

However, this code fails to compile on gcc/Mingw:

    #include &lt;stdint.h&gt;
    #include &lt;stddef.h&gt;
    
    typedef uint8_t array_t [SIZE_MAX];

&gt; error: size of array &#39;array_t&#39; is too large

Am I misunderstanding something in the standard here? Is `size_t` allowed to be too large for a given implementation?  Or is this another bug in Mingw?

---

EDIT: further research shows that 

    typedef uint8_t array_t [SIZE_MAX/2];   // does compile
    typedef uint8_t array_t [SIZE_MAX/2+1]; // does not compile

Which happens to be the same as

    #include &lt;limits.h&gt;

    typedef uint8_t array_t [LLONG_MAX];           // does compile
    typedef uint8_t array_t [LLONG_MAX+(size_t)1]; // does not compile

So I&#39;m now inclined to believe that this is a bug in Mingw, because setting the maximum allowed size based on a signed integer type doesn&#39;t make any sense.

Content Type	Original Author	Original Content on Stackoverflow
Question	Justicle	View Question on Stackoverflow
Solution 1 - C	AnT	View Answer on Stackoverflow
Solution 2 - C	nategoose	View Answer on Stackoverflow
Solution 3 - C	kalmiya	View Answer on Stackoverflow
Solution 4 - C	Praetorian	View Answer on Stackoverflow
Solution 5 - C	Shital Shah	View Answer on Stackoverflow

What is a portable method to find the maximum value of size_t?

C Problem Overview

C Solutions

Solution 1 - C

Solution 2 - C

Solution 3 - C

Solution 4 - C

Solution 5 - C

How to make output of any shell command unbuffered?

Replacing ld with gold - any experience?

Attributions