int and const int in C++

It might or might not be, depending on how it's used. Most compilers are pretty smart about not creating storage for a const object if they don't need it. So, for example:

void f() {
    const int arr_size = 10;
    int arr[arr_size];
    // do something with arr
}

Here, the only use of arr_size is to specify the size of the array. There's no need to create an int object for that; the compiler just creates an array of size 10.

On the other had:

void f(const int* ip) {
    // do something with ip
}

int main() {
    const int n = 100;
    f(&n);
    return 0;
}

Here, the compiler has to create an int object for n, because the code takes the address of n.

Same amount of memory is used since they both allocate the size of an int. The only reason to use const is of course to define a constant for a certain pin or value that won't change. int can be read and write, const int can just be read. The reason why const int saves space is because the compiler treat is a value that won't change, so it won't make any adjustments that will allow it to modify its value, thus saving memory.

Const is a thing meant to make the variables not assignable. It is something on a high level to prevent violating the intended constraints. You will not notice any effect, unless for actual constants. (Where I would recommend constexpr instead)

Will this influence memory? No, simply adding const doesn't change anything to the int (or any other class).

Will this assist in optimization? No, compilers are smart enough to deduce constness on it's own if you don't have it.

Why use it? To enforce an API, indicate intend ...

In C++ unless a const variable's address is taken it is treated as a literal constant and inserted into the code as if its value had been entered literally. That is to say:

const int BUFFLEN = 16 ;
char buffer[BUFFLEN] ;

will generate the same code as:

char buffer[16] ;

The const BUFFLEN does not exist in the memory map as a separate object unless its address is explicitly referenced for example:

printf( "%p", &BUFFLEN ) ;

Given that its address is not referenced, the code generated will be smaller than if it existed in a specific address and had to be fetched and loaded into a register each time it were used.

Moreover no non-const int must exist in R/W memory, but if it has a const initialiser, that initialisation value must exist in the code space too. So for example:

int foo = 16 ;

Will consume space in RAM and also store the initialiser value in ROM (in the case of an Arduino) which is copied to the RAM on start-up before main or any global static object constructors.

So yes it is possible indeed likely that a const will consume fewer resources than a non-const. But I would it is kind of a side-effect of the semantics of const rather than its purpose.