Многосвязное связывание SAPUI5

C ++ дает вам три способа передать объект: по указателю, по ссылке и по значению. Java ограничивает вас последним (единственное исключение - это примитивные типы, такие как int, boolean и т. Д.). Если вы хотите использовать C ++ не просто как странную игрушку, тогда вам лучше узнать разницу между этими тремя способами.

Java делает вид, что нет такой проблемы, как «кто и когда должен уничтожать это?'. Ответ: сборщик мусора, большой и ужасный. Тем не менее, он не может обеспечить 100% защиту от утечек памяти (да, java может просочиться память ). На самом деле, GC дает вам ложное чувство безопасности. Чем больше ваш внедорожник, тем дольше ваш путь к эвакуатору.

C ++ оставляет вас лицом к лицу с управлением жизненным циклом объекта. Ну, есть средства для борьбы с этим ( умные указатели , QObject в Qt и т. Д.), Но ни один из них не может использоваться в режиме «огонь и забыть», как GC: вы всегда должны держать в виду обработки памяти. Вы не только должны заботиться об уничтожении объекта, но и избегать уничтожения одного и того же объекта более одного раза.

Не испугались? Хорошо: циклические ссылки - обрабатывайте их самостоятельно, человек. И помните: убивайте каждый объект ровно один раз, мы C ++ runtimes не любят тех, кто воюет с трупами, оставляют мертвых в одиночестве.

Итак, вернемся к вашему вопросу.

Когда вы передайте свой объект по значению, а не по указателю или по ссылке, вы копируете объект (весь объект, будь то пара байтов или огромный дамп базы данных - вы достаточно умны, чтобы избежать последнего, не так ли? ?) каждый раз, когда вы делаете «=». И чтобы получить доступ к членам объекта, вы используете '.' (точка).

Когда вы передаете свой объект по указателю, вы копируете только несколько байтов (4 в 32-битных системах, 8 на 64-битных), а именно - адрес этого объекта. И чтобы показать это всем, вы используете этот причудливый оператор «->» при доступе к членам. Или вы можете использовать комбинацию «*» и «.».

Когда вы используете ссылки, вы получаете указатель, который претендует на значение. Это указатель, но вы получаете доступ к членам через «.».

И, чтобы раздуть ваш ум еще раз: когда вы объявляете несколько переменных, разделенных запятыми, тогда (смотрите на руки):

• Тип дается всем
• Значение / указатель / ссылочный модификатор индивидуально

Пример:

struct MyStruct
{
    int* someIntPointer, someInt; //here comes the surprise
    MyStruct *somePointer;
    MyStruct &someReference;
};

MyStruct s1; //we allocated an object on stack, not in heap

s1.someInt = 1; //someInt is of type 'int', not 'int*' - value/pointer modifier is individual
s1.someIntPointer = &s1.someInt;
*s1.someIntPointer = 2; //now s1.someInt has value '2'
s1.somePointer = &s1;
s1.someReference = s1; //note there is no '&' operator: reference tries to look like value
s1.somePointer->someInt = 3; //now s1.someInt has value '3'
*(s1.somePointer).someInt = 3; //same as above line
*s1.somePointer->someIntPointer = 4; //now s1.someInt has value '4'

s1.someReference.someInt = 5; //now s1.someInt has value '5'
                              //although someReference is not value, it's members are accessed through '.'

MyStruct s2 = s1; //'NO WAY' the compiler will say. Go define your '=' operator and come back.

//OK, assume we have '=' defined in MyStruct

s2.someInt = 0; //s2.someInt == 0, but s1.someInt is still 5 - it's two completely different objects, not the references to the same one