Question: I am using the Laravel 5.6 Storage API to store my files in `public/storage/images`. This works fine. When I want to retrieve a full URL for one of these files, I use

```
$path = Storage::disk('public')->url('images/' . $url);

```

This returns

> 
> <http://localhost:1234/public/storage/images/foobar.jpg>
> 
> 
> 

But since my server is set up to ignore `public`, this address does not return the image. Instead, this address:

> 
> <http://localhost:1234/storage/images/foobar.jpg>
> 
> 
> 

returns the image. Is there any way to produce this address using Laravel's API, rather than doing an ugly find & replace?

Answer: 
`arr[]`, as a function parameter, is a pointer. `sizeof(arr)/sizeof(arr[0]);` is the size of a pointer/size of of an `int`. No arrays involved. 

> 
> Is Variable size in C compiler dependent?
> 
> 
> 

Yes, an `int` could be 32-bit, 16-bit, etc.1 (Must be at least 16)

An object pointer could be 16-bit, 32-bit, 64-bit, or etc.1 (Must be at least 16)

A pointer is often wider than an `int`, yet could be the same or (rarely) less. The ratio could be 2/1 or 1/1 or others.

---

1 Other sizes are possible and have been employed such as 36-bit `int` or 48-bit object pointer. This is C's ability to adopt to just about any processor ever built and likely to all new ones. The flexibility comes at the expense that *portable* code must account for these variations.
Yes, the sizes of types are implementation-dependent. In particular, the size of a pointer to `int` and the size of an `int` are dependent on the C implementation (primarily a compiler) and may be different from each other.

The assertion in the question contained in “the base address of the array(*which is 4 bytes for an implicit pointer variable and integer variable both*)” is false, in general. It is true in some C implementations but is false in others.

The code `sizeof(arr)/sizeof(arr[0])` inside a function declared with `void print(int arr[])` prints the size of a pointer to `int` divided by the size of an `int`.

While C implementations are heavily influenced by the architectures and the operating systems they target, they may choose the sizes of their types for reasons other than execution speed, such as goals of supporting smaller memory use, supporting code that was not written to be fully portable to any type sizes, or supporting easier use of big integers.