lament meadow
using Index = std::ptrdiff_t;
// Sample loop using index
for (Index index{ 0 }; index < static_cast<Index>(arr.size()); ++index)
why did the learncpp example uses ptrdifft? and why is it casing it to arr size? and why is it saying "what signed type should we use?" why can't u just use int
btw show me an example code of int being ineffective and will make the code break unless u use ptrdifft
cerulean geodeBOT
latent pasture
```cpp
using Index = std::ptrdiff_t;
// Sample loop using index
for (Index inde...
ptrdiff_t is the size of a pointer but signed to make up for negative offsets
int, which is usually 32 bit, is prone to being overflowed/underflowed
arr size returns the unsigned pointer size which needs to be casted back to signed pointer size
i think ssize is probably the better alternative as its always signed
lament meadow
it's better for u to just give me an example code bc i have trouble understanding it
lament meadow
```cpp
using Index = std::ptrdiff_t;
// Sample loop using index
for (Index inde...
like this look can just be used as pointer, make it so that only it can be used for ptrdifft and not an int
@latent pasture pls
languid otter
```cpp
using Index = std::ptrdiff_t;
// Sample loop using index
for (Index inde...
do you know what an pointer address is ?
the underlying type ?
latent pasture
like this look can just be used as pointer, make it so that only it can be used ...
rephrase?
uncut totem
it's better for u to just give me an example code bc i have trouble understandin...
Allocate 3GB on heap, and subtract the last byte's address with the first and cast to int.
latent pasture
i cant give an example its just an integer
languid otter
Allocate 3GB on **heap**, and subtract the last byte's address with the first an...
Allocate 3GB on stack
uncut totem
Bruh, heap I meant!
uncut totem
i wonder if you can even get 3gb on stack
It's mostly limited to a few megabytes.
latent pasture
if you want to iterate over a array using ptrs or iterators or unsigned integers would be better
languid otter
uncut totem
It's mostly limited to a few megabytes.
Or even KBs.
lament meadow
Allocate 3GB on **heap**, and subtract the last byte's address with the first an...
so if I make index value to 10000000000000000 and make it an int, it won't work unless it's a ptrdifft?
lament meadow
```cpp
using Index = std::ptrdiff_t;
// Sample loop using index
for (Index inde...
this variable
not array
uncut totem
so if I make index value to 10000000000000000 and make it an int, it won't work ...
It won't work until the number you gave makes sense in pointer difference situations and that if it does the ptrdiff is large enough to hold it.
lament meadow
give me a code that represents what ur talking about pls
how large can ptrdifft hold btw
uncut totem
how large can ptrdifft hold btw
2⁶⁴ ÷ 2
languid otter
2^63
lament meadow
give me a code that represents what ur talking about pls
ok but don't ignore this one bro 😔
languid otter
give me a code that represents what ur talking about pls
learn about pointer arithmetic
then you will understand what std::ptrdiff_t does
or should do
lament meadow
why are u refusing to send an example code tho
just send it so I can look at it after I understand some
languid otter
if you don't understand pointer arithmetic then you won't understand neither the code example
#include <cstddef>
#include <iostream>
int main()
{
const std::size_t N = 10;
int* a = new int[N];
int* end = a + N;
for (std::ptrdiff_t i = N; i > 0; --i)
std::cout << (*(end - i) = i) << ' ';
std::cout << '\n';
delete[] a;
}
how large does the element have to be to make it only for ptrdifft
uncut totem
;compile
constexpr unsigned limit = std::numeric_limits<int>::max() + 1U; // 2'731'540'480;
auto *pb = new std::byte[limit];
auto *pe = pb + limit;
assert(pb);
int diff = pe - pb;
std::ptrdiff_t pdiff = pe - pb;
// std::printf("%p\n%p\n", pb, pe);
std::cout << "allocated: " << limit << "\nwith int: " << diff << "\nwith ptrdiff: " << pdiff;
karmic breachBOT
uncut totem
how large does the element have to be to make it only for ptrdifft
Look at this.
lament meadow
;compile
constexpr unsigned limit = 2731540479;
auto *pb = new char[limit];
auto *pe = pb + limit;
assert(pb);
int diff = pe - pb;
std::ptrdiff_t pdiff = pe - pb;
// std::printf("%p\n%p\n", pb, pe);
std::cout << "with int: " << diff << '\n' << "with ptrdiff: " << pdiff;
What?
uncut totem
It overflowed.
uncut totem
how did it become negative
The above example allocates 1byte more than 2GB, (2Gigs being the upper limit of int) so INT_MAX + 1, overflows the int, that's why it's really not fit for pointer difference.
lament meadow
but why does it +1 the int_max
uncut totem
but why does it +1 the int_max
To overflow it.
lament meadow
why do u want to overflow it and then just -1 it after 💀 (or im misunderstanding it)
uncut totem
Not really -1'ing now, at this time it represents the canonical range, the pe is off the end pointer.
uncut totem
If you don't understand any of this, just keep in mind, int may not be fit for pointer difference, always opt for implementation defined std::ptrdiff_t, it exists for a reason just like std::size_t.
grizzled mica
;compile
```cpp
constexpr unsigned limit = std::numeric_limits<int>::max() + 1U;...
don't forget to delete[]
uncut totem
Just an example, I'm sure it's returned to the system after the program terminate s.