Fungsi#

Perkenalan #

Fungsi adalah komponen fundamental dalam pemrograman C++, yang mengemas potongan kode menjadi bagian kode yang efisien dan dapat digunakan kembali, yang dirancang untuk melakukan tugas tertentu. Fungsi dapat dipanggil beberapa kali dalam sebuah program, sehingga memudahkan pengorganisasian kode dan membantu menghindari pengulangan kode. Fungsi juga membuat kode lebih mudah di-debug.

Halaman ini membahas dasar-dasar penggunaan fungsi dalam C++, termasuk:

Struktur dan Sintaks Fungsi — Cara penulisan fungsi dalam C++, termasuk tipe pengembalian, nama, dan parameter.
Prototipe Fungsi — Apa itu fungsi prototipe dan mengapa fungsi prototipe digunakan.
Mendefinisikan dan Memanggil Fungsi — Cara membuat fungsi dan memanggilnya dari program Anda.
Nilai Kembalian — Bagaimana fungsi dapat mengirim data kembali ke pemanggil.
Melewati dengan Referensi — Bagaimana fungsi dapat memodifikasi variabel di luar cakupannya sendiri.
Fungsi Callback — Bagaimana fungsi dapat diteruskan ke fungsi lain dan dipanggil secara otomatis sebagai respons terhadap suatu peristiwa.
Fungsi dengan Argumen Default — Cara parameter dapat diberi nilai default ketika tidak ada argumen yang diberikan.

Struktur dan Sintaksis Fungsi #

Dalam C++, fungsi harus dideklarasikan dengan tipe kembalian, nama, dan parameternya. Sintaks dasarnya adalah:

return_type function_name(parameters) {
  // Code to execute when the function is called
  return result;  // Optional, used to return a value
}

Bagian Fungsional	Keterangan
`return_type`	Tipe data yang dikembalikan oleh fungsi, beberapa opsi umum adalah: `void` — Tidak mengembalikan apa pun `int` — Mengembalikan nilai integer `double` — Mengembalikan bilangan floating-point `bool` — Mengembalikan `true` atau `false` `char` — Mengembalikan satu karakter `const char*` — Mengembalikan string teks tipe yang ditentukan pengguna — Mengembalikan `struct` atau objek kelas
`function_name`	Nama fungsi tersebut.
`parameters`	Opsional. Daftar parameter bertipe yang dipisahkan koma, ditulis sebagai `type name`, di mana `type` menentukan tipe data parameter dan `name` adalah pengidentifikasi yang digunakan untuk mengakses nilai tersebut di dalam fungsi. Parameter menerima nilai masukan saat fungsi dipanggil.
`result`	Optional. The value returned by the function. If the function’s `return_type` is not `void`, this value must be provided and its type must exactly match the specified `return_type`.

Catatan: Sebuah fungsi harus selalu dideklarasikan sebelum dipanggil, atau Anda harus menyediakan prototipe fungsi.

Prototipe Fungsi #

Dalam C++, kode dibaca dari atas ke bawah. Ini berarti sebuah fungsi harus dikenal oleh kompiler sebelum dapat dipanggil.

Prototipe fungsi memungkinkan Anda menggunakan sebuah fungsi sebelum menulis kode lengkapnya. Ini memungkinkan Anda untuk tetap menempatkan main() di dekat bagian atas program Anda sambil menempatkan definisi fungsi di bagian selanjutnya, di mana lebih mudah untuk diatur dan dibaca.

Tanpa prototipe, Anda harus mendefinisikan setiap fungsi di atas main(), yang dapat membuat proyek lebih sulit diikuti seiring perkembangannya.

Definisikan prototipe fungsi (di luar int main())

// The function's prototype
void greeting();

Panggil fungsi di dalam int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  greeting();
}

Tuliskan isi fungsi setelahnya.

void greeting() {
  Brain.Screen.print("Hello!");
}

Mendefinisikan dan Memanggil Fungsi #

Functions with No Parameters #

Jika suatu fungsi tidak memerlukan input, Anda dapat mendefinisikannya tanpa parameter. Gunakan void sebagai tipe kembalian jika fungsi tersebut tidak mengembalikan nilai.

Definisikan fungsi (di luar int main())

// Define a function to display a message
void greeting() {
    Brain.Screen.print("Hello!");
}

Panggil fungsi di dalam int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Call the function to display the message
  greeting();
}

Functions with Parameters #

Anda juga dapat menambahkan parameter ke fungsi, yang memungkinkan Anda untuk memberikan informasi yang akan digunakan oleh fungsi tersebut.

Catatan: Teks dapat dilewatkan menggunakan string gaya C (const char*) atau string C++ (std::string).

Definisikan fungsi (di luar int main())

// Define a function with a parameter
void namedGreeting(const char* name) {
    Brain.Screen.print("Hello, %s!", name);
}

Panggil fungsi dengan parameter di dalam int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Call the function to display the message
  namedGreeting("Stranger");
}

Nilai Kembalian #

Fungsi dapat mengirim data kembali ke pemanggil menggunakan kata kunci return Ini memungkinkan Anda untuk menangkap dan menggunakan output dalam proyek Anda.

Definisikan fungsi (di luar int main())

// Define a function that multiplies numbers by 2
int timesTwo(int number) {
    return number * 2;
}

Panggil fungsi dengan parameter di dalam int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Display the return value
  Brain.Screen.print("%d", timesTwo(2));
}

Referensi yang Dilewati #

Secara default, C++ meneruskan parameter fungsi berdasarkan nilai, artinya fungsi tersebut menerima salinan dari variabel asli. Perubahan yang dilakukan di dalam fungsi tidak memengaruhi nilai aslinya.

Definisikan fungsi (di luar int main())

// Add 1 to the number
void addOne(int number) {
  number++;
}

Panggil fungsi dengan parameter di dalam int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  int value = 5;
  addOne(value);
  // "value" will still be 5
}

Untuk memungkinkan suatu fungsi memodifikasi variabel asli, parameter dapat dilewatkan dengan referensi menggunakan simbol &.

Definisikan fungsi (di luar int main())

// Add 1 to the number
void addOne(int& number) {
  number++;
}

Panggil fungsi dengan parameter di dalam int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  int value = 5;
  addOne(value);
  // "value" will now be 6
}

Melewatkan dengan referensi memungkinkan fungsi untuk memperbarui variabel yang didefinisikan di luar fungsi tanpa mengembalikan nilai.

Fungsi Panggilan Balik #

Fungsi callback adalah fungsi yang diteruskan ke fungsi lain dan dipanggil secara otomatis ketika suatu peristiwa tertentu terjadi.

Fungsi callback umumnya digunakan untuk peristiwa seperti penekanan tombol atau pembaruan sensor.

Alih-alih memanggil fungsi tersebut sendiri, proyek akan memanggilnya untuk Anda ketika peristiwa itu terjadi.

Definisikan fungsi callback (di luar int main())

// Create a callback function
void onPressed() {
  Brain.Screen.print("Screen pressed!");
}

Daftarkan fungsi callback di dalam int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Call onPressed whenever the screen is pressed
  Brain.Screen.pressed(onPressed);
}

Callback Signatures #

Setiap fungsi callback harus mengikuti tanda tangan tertentu, yang mendefinisikan:

Tipe pengembalian
Jumlah parameter
Jenis parameter

Tanda tangan yang dibutuhkan ditentukan oleh API. Fungsi callback harus sama persis dengan tanda tangan ini.

// This callback function cannot include any parameters
void callback(void);

// This callback function includes four parameters
void callback(axisType axis, double x, double y, double z);

Nama parameter bersifat deskriptif dan dapat bervariasi, tetapi tipe kembalian, urutan parameter, dan tipe parameter harus sama persis.

Fungsi dengan Argumen Default #

Fungsi dapat menentukan nilai default untuk satu atau lebih parameter. Argumen default digunakan ketika tidak ada nilai yang diberikan untuk parameter tersebut saat fungsi dipanggil.

Aturan untuk argumen default:

Argumen default harus menjadi parameter terakhir dalam definisi fungsi.
Setelah suatu parameter memiliki nilai default, semua parameter setelahnya juga harus memiliki nilai default.
Jika suatu fungsi menentukan argumen default dalam prototipe, nilai default tersebut tidak boleh ditentukan lagi dalam definisi fungsi.

Definisikan fungsi (di luar int main())

// Required parameter first, default parameter last
void greeting(const char* name, int repeatCount = 1) {

    for (int i = 0; i < repeatCount; i++) {
        Brain.Screen.print("Hello, %s!", name);
        Brain.Screen.newLine();
    }
}

Panggil fungsi di dalam int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Say what name to greet (EXP) and
  // use default value for repeatCount (1)
  greeting("EXP");

  Brain.Screen.newLine();

  // Overrides the default value to 3
  greeting("EXP", 3);
}

// Required parameter first, default parameter last
void greeting(const char* name, int repeatCount = 1) {

    for (int i = 0; i < repeatCount; i++) {
        Brain.Screen.print("Hello, %s!", name);
        Brain.Screen.newLine();
    }
}

int main() {
    vexcodeInit();

    // Say what name to greet (EXP) and
    // use default value for repeatCount (1)
    greeting("EXP");

    Brain.Screen.newLine();

    // Overrides the default value to 3
    greeting("EXP", 3);
}