{"id":413285,"date":"2024-02-28T16:14:51","date_gmt":"2024-02-29T00:14:51","guid":{"rendered":"https:\/\/linuxhint.com\/?p=413285"},"modified":"2025-01-04T14:25:36","modified_gmt":"2025-01-04T22:25:36","slug":"return-reference-cpp","status":"publish","type":"post","link":"https:\/\/linuxhint.com\/return-reference-cpp\/","title":{"rendered":"Return Reference in C++"},"content":{"rendered":"
\n

C++ provides a facility to return a value or an address by its reference rather than pointers. Using references instead of pointers can make a C++ program simpler to read and manage. In C++, references and pointers are closely related to one another. The primary distinction is that although references are merely an alternate name, \u201calias\u201d for another variable, pointers can be used in operations such as adding values. A reference is an alternate name\u00a0or duplicate of the original value and is denoted by the \u201c&\u201dsymbol.<\/p>\n

Example 1:<\/h2>\n

We import the \u201ciostream\u201d header file and then utilize the \u201cstd\u201d namespace. The header files are imported in C++ codes as many functions are defined. Then, we create a return reference function by placing the \u201c&\u201d symbol with the function\u2019s name, \u201creturnTheValue\u201d.<\/p>\n

Here, the \u201cvalue\u201d reference is now inserted. Underneath this, we print the value and the address with the \u201c&value\u201d reference. Then, we place the return reference and place the \u201cvalue\u201d. Now, the \u201cmain()\u201d is invoked here, and we initialize \u201cn1\u201d with the value of \u201c44\u201d. Below this, \u201cint& n2\u201d is initialized with the \u201creturnTheValue(n1)\u201d. Now, we print the value of \u201cn1\u201d as well as its address. Then, we print the value of \u201cn2\u201d as well as the address of \u201cn2\u201d by utilizing the \u201ccout\u201d.<\/p>\n

Code 1: <\/strong><\/p>\n

#include <iostream> <\/span>
\nusing namespace std;
\nint&<\/span> returnTheValue(<\/span>int&<\/span> value)<\/span>
\n{<\/span>
\n    cout <<<\/span> "Value = "<\/span> <<<\/span> value <<<\/span> endl
\n        <<<\/span> " The address of value is "<\/span>
\n        <<<\/span> &<\/span>value <<<\/span> endl;
\n    return<\/span> value;
\n}<\/span>
\nint main(<\/span>)<\/span>
\n{<\/span>
\n    int n1 = 44<\/span>;
\n    int&<\/span> n2 = returnTheValue(<\/span>n1)<\/span>;
\n    cout <<<\/span> "n1 = "<\/span> <<<\/span> n1 <<<\/span> endl
\n        <<<\/span> " The address of n1 is "<\/span>
\n        <<<\/span> &<\/span>n1 <<<\/span> endl;
\n    cout <<<\/span> "n2 = "<\/span> <<<\/span> n2 <<<\/span> endl
\n        <<<\/span> " The address of n2 is "<\/span>
\n        <<<\/span> &<\/span>n2 <<<\/span> endl;
\n    return<\/span> 0<\/span>;
\n}<\/span><\/div><\/div>\n

 
\nOutput:<\/strong><\/p>\n

Here, we can note that a reference is only an alternate name\u00a0of another variable as shown in the following. As the address of value, \u201cn1\u201d and \u201cn2\u201d never change.<\/p>\n

\"\"<\/p>\n

Example 2:<\/h2>\n

We use the “std” namespace after importing the “iostream” header file.\u00a0 Next, we use the function name “MyReturnValueFunc” and the “&” symbol to build a return reference function. The reference to the “v1” variable is placed here. We print the value and the address with the “&v1” reference underneath this. Next, we insert the \u201creturn reference\u201d by utilizing \u201creturn\u201d and “v1” in this location. Here, “main()” is called, and “num_1” is initialized with the value of “19”. The initialization of “int& num_2” is done with “MyReturnValueFunc(num_1)”.<\/p>\n

Currently, we print the value and address of “num_1” and, using “cout”, we print the value and address of “num_2”. We now change the value of \u201cnum_1\u201d by utilizing the address that is returned here by \u201cMyReturnValueFunc\u201d. This function returns the alternate name of \u201cv1\u201d which is also the alternate name of \u201cnum_1\u201d. So, we change its value and set it to \u201c91\u201d. We assign \u201c91\u201d to \u201cMyReturnValueFunc(num_1)\u201d which acts as the alias here. Then, we print the value again and the address of \u201cnum_1\u201d.<\/p>\n

Code 2: <\/strong><\/p>\n

#include <iostream> <\/span>
\nusing namespace std;
\nint&<\/span> MyReturnValueFunc(<\/span>int&<\/span> v1)<\/span>
\n{<\/span>
\n    cout <<<\/span> "The value of v1 = "<\/span> <<<\/span> v1 <<<\/span> endl
\n        <<<\/span> " The address of v1 variable is "<\/span>
\n        <<<\/span> &<\/span>v1 <<<\/span> endl;
\n    return<\/span> v1;
\n}<\/span>
\nint main(<\/span>)<\/span>
\n{<\/span>
\n    int num_1 = 19<\/span>;
\n    int&<\/span> num_2 = MyReturnValueFunc(<\/span>num_1)<\/span>;
\n    cout <<<\/span> "The value of num_1 = "<\/span> <<<\/span> num_1 <<<\/span> endl
\n        <<<\/span> " The address of num_1 is "<\/span>
\n        <<<\/span> &<\/span>num_1 <<<\/span> endl;
\n    cout <<<\/span> "The value of num_2 = "<\/span> <<<\/span> num_2 <<<\/span> endl
\n        <<<\/span> " The address of num_2 is "<\/span>
\n        <<<\/span> &<\/span>num_2 <<<\/span> endl;
\n    MyReturnValueFunc(<\/span>num_1)<\/span> = 91<\/span>;
\n    cout <<<\/span> "Now, the value of num_1 = "<\/span> <<<\/span> num_1 <<<\/span> endl
\n         <<<\/span> "The address of num_1 is "<\/span>
\n         <<<\/span> &<\/span>num_1 <<<\/span> endl;
\n    return<\/span> 0<\/span>;
\n}<\/span><\/div><\/div>\n

 
\nOutput:<\/strong><\/p>\n

As demonstrated in the following, we can see that a reference is merely an alternative name for another variable since the address of the \u201cv1\u201d, \u201cnum_1\u201d, and \u201cnum_2\u201d values remained constant:<\/p>\n

\"\"<\/p>\n

Example 3:<\/h2>\n

The “iostream” header file is imported and the “std” namespace is used. Since numerous functions are specified in the header files, we import them into the C++ codes. Here, we create a \u201cReturnRefFun()\u201d function in which we place \u201cint& my_ref\u201d which returns the reference. The \u201cint& ReturnRefFun\u201d is declared here as the reference function. After this, we increment the value of the \u201cmy_ref\u201d variable. Underneath this, we put \u201creturn\u201d which returns the reference of \u201cmy_ref\u201d.<\/p>\n

After this, the \u201cmain()\u201d method is invoked here. Then, we initialize the \u201cfirst_value\u201d variable with \u201c21\u201d. Below this, we return the copy of the reference by placing \u201cfirst_value\u201d in the \u201cReturnRefFun\u201d function and save it in the \u201ccopied_value\u201d variable. Then, we print both the \u201cfirst_value\u201d as well as the \u201ccopied_value\u201d by utilizing the \u201ccout\u201d. Underneath this, we increment the \u201ccopied_value\u201d variable by placing the \u201ccopied_value++\u201d. Then, we print the \u201ccopied_value\u201d after incrementing it and the \u201cfirst_value\u201d using \u201ccout\u201d. After this, we return the reference with the help of initializing the \u201cint& ref_value\u201d variable with \u201cReturnRefFun(first_value)\u201d.<\/p>\n

After this, we print the value of the \u201cmy_ref\u201d variable which we copied. Then, we print the value of the \u201cfirst_value\u201d variable. Underneath this, we increment the value of \u201cref_value\u201d by putting \u201cref_value++\u201d. Below this, we print the incremented value of \u201cref_value\u201d and also the \u201cfirst_value\u201d variable with the aid of \u201ccout\u201d. When the \u201cref_value\u201d is changed, the \u201cfirst_value\u201d will also change.<\/p>\n

Code 3: <\/strong><\/p>\n

#include <iostream><\/span>
\nusing namespace std;
\nint&<\/span> ReturnRefFun(<\/span>int&<\/span> my_ref)<\/span>{<\/span>
\n    my_ref++;
\n    return<\/span> my_ref;
\n}<\/span>
\nint main(<\/span>)<\/span> {<\/span>
\n    int first_value<\/span>= 21<\/span>;
\n    int copied_value<\/span>=ReturnRefFun(<\/span>first_value)<\/span>;
\n    cout <<<\/span> "The first value is : "<\/span> <<<\/span> first_value <<<\/span> endl;
\n     cout<<<\/span> "The copied value is : "<\/span> <<<\/span> copied_value <<<\/span> endl;
\n    copied_value++;
\n    cout<<<\/span> "The copied_value is incremented: "<\/span> <<<\/span> copied_value <<<\/span> endl;
\n    cout <<<\/span> "The first value : "<\/span> <<<\/span> first_value <<<\/span> endl;
\n    int&<\/span> ref_value<\/span>=ReturnRefFun(<\/span>first_value)<\/span>;
\n    cout <<<\/span> "The reference copied value: "<\/span> <<<\/span> ref_value <<<\/span> endl;
\n    cout <<<\/span> "The first value : "<\/span> <<<\/span> first_value <<<\/span> endl;
\n    ref_value++;
\n    cout <<<\/span> "The reference value is incremented : "<\/span> <<<\/span> ref_value <<<\/span> endl;
\n    cout <<<\/span> "The first value : "<\/span> <<<\/span> first_value <<<\/span> endl;
\n    return<\/span> 0<\/span>;
\n}<\/span><\/div><\/div>\n

 
\nOutput: <\/strong><\/p>\n

Here is the outcome of the previous code where we utilized the \u201creturn reference\u201d technique. The example shows the distinction between returning a duplicate of the reference variable and returning the reference variable itself.<\/p>\n

\"\"<\/p>\n

Example 4:<\/h2>\n

Here, \u201cint& rByRef\u201d is declared as the reference function which returns the reference variable. We pass the \u201cint& data\u201d to this \u201cint& rByref()\u201d function. Here, we print the address of the \u201cdata\u201d variable and then utilize the return reference below this. Now, we initialize the \u201cx_var\u201d variable after invoking the \u201cmain()\u201d method. Then, we print the address of \u201cx_var\u201d here by putting the \u201c&x_var\u201d in the \u201ccout\u201d.<\/p>\n

Underneath this, we utilize the reference variable by assigning \u201crByref(x_var)\u201d to the \u201cint& y_var\u201d. Then, we also print the address of that \u201c&y_var\u201d reference variable. Below this, we copy the \u201cx_var\u201d variable into the \u201cz_var\u201d variable and also print the address of this copied variable which is \u201c&z_var\u201d. After this, we call the \u201crByref()\u201d function, pass the \u201cx_var\u201d variable as the parameter inside it, and assign \u201c93\u201d to this variable. We also render the address of the \u201cx_var\u201d again by putting the \u201c&x_var\u201d in the \u201ccout\u201d.<\/p>\n

Code 4: <\/strong><\/p>\n

#include <iostream><\/span>
\nusing namespace std;
\nint&<\/span> rByref(<\/span>int&<\/span> data)<\/span>
\n{<\/span>
\n    cout<<<\/span> "Address of data: "<\/span><<<\/span> &<\/span>data <<<\/span> endl;
\n    return<\/span> data;
\n}<\/span>
\nint main(<\/span>)<\/span>
\n{<\/span>
\n    int x_var = 42<\/span>;
\n    cout<<<\/span> "Address of x_var: "<\/span><<<\/span> &<\/span>x_var <<<\/span> endl;
\n    int&<\/span> y_var = rByref(<\/span>x_var)<\/span>;
\n    cout <<<\/span> "Address of y_var: "<\/span><<<\/span> &<\/span>y_var <<<\/span> endl;
\n    int z_var = rByref(<\/span>x_var)<\/span>;
\n    cout <<<\/span> "Address of z_var: "<\/span><<<\/span> &<\/span>z_var <<<\/span> endl;
\n    rByref(<\/span>x_var)<\/span> = 93<\/span>;
\n    cout<<<\/span> "Address of x_var: "<\/span><<<\/span> &<\/span>x_var <<<\/span> endl;
\n    return<\/span> 0<\/span>;
\n}<\/span><\/div><\/div>\n

 
\nOutput: <\/strong><\/p>\n

The result makes it clear that the cloned variable’s address, \u201cz_var\u201d, differs from all the other locations that the original variable, \u201cx_var\u201d, references.<\/p>\n

\"\"<\/p>\n

Conclusion<\/h2>\n

The \u201creturn reference\u201d concept is explored in this tutorial in detail. We learned that the \u201creturn reference\u201d is similar to the \u201cpointers\u201d in C++ programming. We discussed that to indicate which function returns a reference, the \u201c&\u201d symbol needs to be utilized with the function’s return type. We illustrated some examples and their outcomes and understood this concept in this tutorial.<\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":"

Tutorial on the \u201creturn reference\u201d concept in C++ by utilizing the \u201c&\u201d symbol with the function’s return type to indicate which function returns a reference.<\/p>\n","protected":false},"author":145,"featured_media":413302,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_wp_convertkit_post_meta":{"form":"-1","landing_page":"","tag":"0","restrict_content":"0"},"footnotes":""},"categories":[1515],"tags":[],"class_list":["post-413285","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cpp"],"_links":{"self":[{"href":"https:\/\/linuxhint.com\/wp-json\/wp\/v2\/posts\/413285","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/linuxhint.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/linuxhint.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/linuxhint.com\/wp-json\/wp\/v2\/users\/145"}],"replies":[{"embeddable":true,"href":"https:\/\/linuxhint.com\/wp-json\/wp\/v2\/comments?post=413285"}],"version-history":[{"count":0,"href":"https:\/\/linuxhint.com\/wp-json\/wp\/v2\/posts\/413285\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/linuxhint.com\/wp-json\/wp\/v2\/media\/413302"}],"wp:attachment":[{"href":"https:\/\/linuxhint.com\/wp-json\/wp\/v2\/media?parent=413285"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/linuxhint.com\/wp-json\/wp\/v2\/categories?post=413285"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/linuxhint.com\/wp-json\/wp\/v2\/tags?post=413285"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}