Contoh 1: Menggunakan Tuple/Pair
Mari lakukan beberapa demonstrasi praktikal untuk mengembalikan berbilang nilai dalam C++. Di sini, kami menggunakan teknik tupel/pasangan untuk membantu mengembalikan berbilang nilai dalam kod kami. C++ menyediakan pelbagai fail pengepala yang perlu kami sertakan dalam kod kami. Kami menyertakan 'bits/stdc++.h' di sini kerana ia mengandungi semua perpustakaan pengaturcaraan C++. Kemudian, ruang nama ditambah di sini iaitu 'std'. Selepas ini, kami menggunakan kata kunci 'tuple' di mana kami meletakkan tiga jenis data, dua jenis data apungan dan baki satu jenis data 'char'. Di bawahnya, kami menggunakan kata kunci 'kembali' untuk mengemas nilai untuk mengembalikan tuple.
Sekarang, kami menggunakan kaedah 'pasangan' untuk mengembalikan berbilang nilai. Dalam kaedah 'pasangan' ini, kami meletakkan dua jenis data pembolehubah, dan kedua-duanya 'terapung' di sini. Pembolehubah dinamakan 'float_1' dan 'float_2'. Kemudian, kami membungkus dua nilai untuk kembali kepada 'pasangan'. Selepas ini, kami menggunakan 'utama()' di sini dan kemudian mengisytiharkan dua pembolehubah 'terapung' dengan nama 'f_1, f_2'. Pembolehubah 'char' juga diisytiharkan di sini sebagai 'myChar'. Kemudian, kami membongkar nilai yang dikembalikan oleh fungsi 'My_Tuple()'.
Di bawah ini, kami menyimpan nilai yang dikembalikan secara berpasangan. Kami menyimpan ”4.99, 8.98” dalam fungsi “My_Tuple” dan “6.86, 3.22” dalam fungsi “My_Pair”. Kemudian, kami menggunakan 'cout' yang mencetak semua maklumat yang tertulis di dalamnya.
Kod 1:
#include
menggunakan ruang nama std ;
tupel < terapung , terapung , char > My_Tuple ( terapung f_1, terapung f_2 ) {
kembali buat_tuple ( f_2, f_1, '$' ) ;
}
sepasang < terapung , terapung > Pasangan_Saya ( terapung f_a, terapung f_b ) {
kembali buat_pasangan ( f_b, f_a ) ;
}
int utama ( ) {
terapung f_1,f_2 ;
char myChar ;
tali leher ( f_1, f_2, myChar ) = My_Tuple ( 4.99 , 8.98 ) ;
pasangan new_p = Pasangan_Saya ( 6.86 , 3.22 ) ;
cout << 'Nilai yang kita dapat dengan tupel : ' ;
cout << f_1 << ' ' << f_2 << ' ' << myChar << endl ;
cout << 'Nilai yang kita perolehi dengan Berpasangan: ' ;
cout << new_p. pertama << ' ' << new_p. kedua ;
kembali 0 ;
}
Pengeluaran :
Nilai yang kami dapat di sini dengan menggunakan kaedah 'tuple' dan 'pasangan' dipaparkan dalam perkara berikut. Ambil perhatian bahawa ia mengembalikan berbilang nilai di sini.
Contoh 2: Menggunakan Penunjuk
Kami lulus parameter bersama-sama dengan alamat mereka dalam fungsi 'bandingkan' di sini. Kami menambah 'nilai_1' dan 'nilai_2' jenis 'int' dan 'int* g_Address, int* s_Address'. Selepas ini, kami menggunakan syarat 'jika' di mana kami menambah syarat bahawa 'nilai_1' lebih besar daripada 'nilai_2'. Jika ini berpuas hati, pernyataan berikut dilaksanakan. Jika tidak, ia mengabaikan pernyataan yang ditambahkan di bawah ini dan bergerak ke arah bahagian 'lain'. Kini, selepas menggunakan 'main()', kami mengisytiharkan empat pembolehubah baharu dengan nama 'g_value', 's_value', 'newValue1', dan 'newValue2'.
Selepas ini, kami mencetak mesej untuk memasukkan nombor dan kemudian meletakkan 'cin' yang mendapat dua nilai daripada pengguna. Nilai yang dimasukkan pengguna disimpan dalam pembolehubah 'newValue1' dan 'newValue2', masing-masing. Selepas ini, kami memanggil fungsi 'compare()' yang kami buat sebelum ini dan lulus empat parameter ke dalamnya. Kemudian, kami memaparkan hasilnya selepas melaksanakan fungsi 'bandingkan' dan ia menunjukkan nombor yang lebih besar dan nombor yang lebih kecil daripada nombor yang dimasukkan pengguna.
Kod 2:
#includemenggunakan ruang nama std ;
batal bandingkan ( int nilai_1, int nilai_2, int * g_Alamat, int * s_Alamat )
{
jika ( nilai_1 > nilai_2 ) {
* g_Alamat = nilai_1 ;
* s_Alamat = nilai_2 ;
}
lain {
* g_Alamat = nilai_2 ;
* s_Alamat = nilai_1 ;
}
}
int utama ( )
{
int g_value, s_value, newValue_1, newValue_2 ;
cout << 'Sila Masukkan dua nombor: ' <> newValue_1 >> newValue_2 ;
bandingkan ( newValue_1, newValue_2, & g_value, & s_value ) ;
cout << ' \n Bilangan yang lebih besar ialah ' << g_value << 'dan nombor yang lebih kecil ialah'
<< s_value ;
kembali 0 ;
}
Pengeluaran :
Pengguna memasukkan '86' dan '23' di sini. Selepas menekan 'Enter', ia memaparkan hasilnya. Dengan cara ini, kita mendapat berbilang nilai.
Contoh 3: Menggunakan Array
Kami mencipta fungsi 'ComputeComparison()' di sini di mana kami memasukkan dua pembolehubah, 'num_1' dan 'num_2', sebagai jenis 'int' dan juga tatasusunan bernama 'my_arr[]'. Selepas ini, kita mempunyai syarat 'jika' yang menyemak sama ada 'num_1' lebih besar daripada 'num_2' atau tidak. Jika ia benar, 'num_1' diberikan kepada 'my_arr[0]' dan 'num_2' diberikan kepada 'my_arr[1]'. Tetapi jika syarat itu tidak benar, pernyataan selepas 'else' dilaksanakan di mana kami menetapkan 'num_2' kepada 'my_arr[0]' dan 'num_1' kepada 'my_arr[1]'.
Selepas ini, kami memanggil 'main()' di sini dan kemudian mengisytiharkan dua lagi pembolehubah int: 'newNum_1' dan 'newNum_2'. Selepas ini, tatasusunan saiz '2' diisytiharkan. Selepas ini, kami mendapat dua nombor daripada pengguna dengan bantuan 'cin' dan kemudian memanggil fungsi 'ComputeComparison()' dan memaparkan hasil berikut. Jadi, ia mengembalikan berbilang nilai di sini.
Kod 3:
#includemenggunakan ruang nama std ;
batal ComputeComparison ( int num_1, int num_2, int my_arr [ ] )
{
jika ( num_1 > num_2 ) {
my_arr [ 0 ] = num_1 ;
my_arr [ 1 ] = num_2 ;
}
lain {
my_arr [ 0 ] = num_2 ;
my_arr [ 1 ] = num_1 ;
}
}
int utama ( )
{
int newNum_1, newNum_2 ;
int my_arr [ 2 ] ;
cout << 'Sila Masukkan dua nombor untuk perbandingan' <> newNum_1 >> newNum_2 ;
ComputeComparison ( newNum_1, newNum_2, my_arr ) ;
cout << ' \n Bilangan yang lebih besar ialah ' << my_arr [ 0 ] << ' dan juga '
'nombor yang lebih kecil ialah' << my_arr [ 1 ] ;
kembali 0 ;
}
Pengeluaran :
Kami menaip kedua-dua '54' dan '98' di sini dan kemudian tekan 'Enter' untuk memaparkan hasilnya. Ia menunjukkan nombor yang lebih besar dan juga lebih kecil daripada nombor yang kami masukkan.
Contoh 4: Menggunakan Tuple
Dua fail pengepala disertakan di sini: 'tuple' dan 'iostream'. Seterusnya, ruang nama 'std' diletakkan di sini. Seterusnya, kami menggunakan kata kunci 'tuple' dan memasukkan dua jenis data iaitu 'int'. Selepas ini, kami mencipta fungsi dengan nama 'findingValues()' dan lulus 'intValue_1' dan 'intValue2' sebagai parameternya.
Kemudian, 'jika' diletakkan di mana kita menaip keadaan 'intValue_1 < intValue_2'. Di bawahnya, kami menggunakan kata kunci 'return' dan meletakkan fungsi 'make_tuple()' di mana kedua-dua pembolehubah ditambah sebagai parameter 'intValue_1, intValue2_'. Kemudian, kita mempunyai bahagian 'lain' di mana kita meletakkan 'kembali' sekali lagi bersama-sama dengan fungsi 'make_tuple()'. Tetapi di sini, kami meletakkan 'intValue_2' dahulu dan kemudian 'intValue1'. Sekarang, kami memanggil 'main()' dan memulakan 'new_value1' dengan '5' dan 'new_value2' dengan '28'.
Dalam perkara berikut, kami mengisytiharkan dua lagi pembolehubah jenis 'int' dengan nama 'lebih besar' dan 'lebih kecil'. Kemudian, kami meletakkan fungsi 'tie()' dan lulus pembolehubah 'smaller, greater' sebagai parameter dan juga memanggil fungsi 'findingValues()' di sini. Selepas ini, kami mencetak kedua-dua nilai: nombor yang lebih besar dan lebih kecil.
Kod 4:
#include#include
menggunakan ruang nama std ;
tuple findingValues ( int intValue_1, int intValue_2 )
{
jika ( intValue_1 < intValue_2 ) {
kembali buat_tuple ( intValue_1 , intValue_2 ) ;
}
lain {
kembali buat_tuple ( intValue_2 , intValue_1 ) ;
}
}
int utama ( )
{
int new_value1 = 5 , new_value2 = 28 ;
int lebih besar, lebih kecil ;
tali leher ( lebih kecil, lebih besar ) = findingValues ( new_value1, new_value2 ) ;
printf ( 'Nombor yang lebih besar ialah %d dan '
'nombor yang lebih kecil ialah %d' ,
lebih besar, lebih kecil ) ;
kembali 0 ;
}
Pengeluaran :
Nombor yang kami tambahkan pada kod kami secara serentak memaparkan nilai yang lebih besar dan lebih kecil. Dengan cara ini, kami boleh dengan mudah mengembalikan berbilang nilai dalam kod kami.
Kesimpulan
Panduan ini adalah mengenai 'memulangkan berbilang nilai' dalam kod C++. Kami meneroka idea ini dengan teliti dalam panduan ini dan membincangkan tiga teknik yang membantu dalam mengembalikan berbilang nilai dalam pengaturcaraan C++. Kami menjelaskan bahawa berbilang nilai dikembalikan dengan menggunakan tupel, pasangan, penunjuk dan teknik tatasusunan. Semua teknik ini diterangkan dengan teliti di sini.