It really sounds like you don't understand the difference between references and pointers. Can you, without testing, tell me what the following quick code would output? Be as specific as you are able to.

I know the difference, it sounds you seem to not pick it up from me, I'll try to phrase it in a more definitive way then:

-Reference provides adress of a variable/ a pointer to the memory of the variable.

-Pointer is a whole unsigned integer number, that is an address in memory, can be of 4 or 8 bytes large.

int value=1;

myFirstFunction(value);/*Console is written some whole number that points to the momory where 4 bytes on "value are"*/

myFirstFunction(1); /* Console is written some whole number that points to the memory where 4 bytes of a stacked local param is */

mySecondFunction(&value); /*Console is written some whole number that points to the memory where 4 bytes on "value are"*/

int main()
{
int myInt = 7;

myFirstFunction(myInt); // as I said, address of myInt
mySecondFunction(&myInt);// as I siad, same number
}

I know the difference, it sounds you seem to not pick it up from me.

No, you do not know, as demonstrated by your answer:

int value=1; myFirstFunction(value);/*Console is written some whole number that points to the momory where 4 bytes on "value are"*/ myFirstFunction(1); /* Console is written some whole number that points to the memory where 4 bytes of a stacked local param is */

Blantantly wrong.

int value = 1;
myFirstFunction(value);

Will print out "1". References behave exactly like value/variables wherever they are used. In order to get the address of the thing the reference points to, you have to promote it to a pointer via &. (&value).

myFirstFunction(1);

This won't even compile (on a standard-comformant compiler). You cannot bind a temporary to a non-const reference.

In order to get the address of the thing the reference points to, you have to promote it to a pointer via &. (&value).

In my knowledge, if a parameter is declared as Type &vari , and recieves an instance of Type on itself, it will provide sole address of that variable. Either- it is not actual anymore, or, it hasn't been true about basic integrated types of the language?

I have gonne to the web-page, and for the 98 standard, the one before C++11, compilation hangs on work, if I apply a custom type instead of int type to the inspected variable. Your observation about a need to reference & before the passed variable could not apply to not-value passed instances to parameters, I am still investigating this issue.

References behave exactly like value/variables wherever they are used. In order to get the address of the thing the reference points to, you have to promote it to a pointer via &. (&value).

Very inccorrect generalization, you must admit that's actualy omitting a reference existance?

So this code hang on me for the very link link, I alter only compilation standard to first one.

#include <iostream>

class SomeType{
    public:
    SomeType(){}
    int a;
    int b;
    int c;
    };
    
void myFirstFunction(SomeType &value)
{
    std::cout << value << std::endl;
}

void mySecondFunction(SomeType *value)
{
    std::cout << value << std::endl;
}

int main()
{
  SomeType myInt();
  
  myFirstFunction(myInt);
  mySecondFunction(&myInt);
}

Very inccorrect generalization, you must admit that's actualy omitting a reference existance?

What are you talking about?

I said references behave like a value-type, of course they point to another variable, but the point is this - an operation cannot possibly aquire the address of whatever the reference is pointing to, without promoting to pointer.

All of this:

int x = 1;
int& y = x;

y += 1; // does NOT increment the address
std::cout << y;
y = 5; // does NOT set the address to 5
printf("%i", y);

Is functionally 100% equivalent to:

int x = 1;

x += 1;
std::cout << x;
x = 5;
printf("%i", x);

The reference acts as an alias to another variable. Sure its underneath value is a pointer like 0xAB6492F, but whenever you perform another operation on it, it performs the operation on the original variable, as if the reference was a pointer that has been wrapped with "(*pValue)" . If you want to get the address, you need to use &.

EDIT:

So this code hang on me for the very link link, I alter only compilation standard to first one.

Yeah, this code does not compile. First off:

SomeType myInt();

Does not create an instance of SomeType, but a SomeType (*)() function pointer. Change it to:

SomeType myInt;

Plus:

void myFirstFunction(SomeType &value)
{
    std::cout << value << std::endl; // compilation error
} 

I'm not going to explain why this fails. Take what I explained about references, and you should see for yourself why cout cannot print SomeType&, but can print SomeType*.

In my knowledge this'd have been equivalent to that code:

int x = 1;
int& y = x; // snatches addreess of x into actual int* y

*y += 1; // does NOT increment the address
std::cout << *y;
*y = 5; // does NOT set the address to 5
printf("%i", *y);

I havent used references for so long. I am still not sure for pre-11 standard???

Since, for example:

int* a;

int** ap=&a;

**ap - provides *a