Main & CLAs

Main

Definition

The main function is crucial because it is the starting point of a C++ program. It allows you to define the program’s logic and perform various operations based on your requirements. It also provides an entry point for the program to interact with the operating system and handle command-line arguments, if necessary. Without a main function, the program cannot be executed as a standalone program.

Use Cases

CLAs

Working with Command-line Arguments

• allows for variables to be left defined at runtime

Executables

Executing compiled code

Pros & Cons

👍

Code organization

Provides a clear structure for where execution begins

Control flow

Allows you to manage program flow efficiently

Reusability

Promotes reusable code

👎

Complexity

In some languages, a main function may introduce unnecessary complexity

Limited flexibility

In some cases, it might not be suitable for specific program types

main Syntax

Pseudocode

pseudocode for main function:
   begin
      // Your program logic here
   end

C++

#include <iostream>
int main() {
   std::cout << "Hello, World!" << std::endl;
   return 0;
}

Python

def main():
    print("Hello, World!")

if __name__ == "__main__":
    main()

Java

// Java Main Function Example
public class MainExample {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Rust

// Rust Main Function Example
fn main() {
    println!("Hello, World!");
}

Golang

<iframesrc=“https://www.youtube.com/embed/380D9mmWXl8?si=5RyMKgeytpo9QRv7” title=“YouTube video player” frameborder=“0” allow=“accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share” allowfullscreen>

// Go Main Function Example
package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Output

In each main function, the objective is to define the entry point for the program And print the common ‘simple program’ example of “Hello, World!” to the terminal

Hello, World!

Command-line Arguments

Definition

argc

• argument count : keeps track of the total number of arguments passed at runtime

argv argument vector : a vector collection of arguments passed and accessible at runtime

Use Cases

Accepting user input from the command line

Configuring program behavior using command-line options

Pros & Cons

👍

Flexibility

Users can customize program behavior without changing the code

Automation

Batch processing and scripting become possible

Standardization

A common way to interact with command-line programs

👎

Complexity

Handling command-line arguments can become complex for advanced use cases

Error-prone

Incorrect input can lead to unexpected behavior

argc & argv Syntax

Pseudocode

pseudocode for handling argc and argv:
   begin
      // Parse command-line arguments
      if argc > 1:
         for i from 1 to argc-1:
            if argv[i] is a valid option:
               // Handle the option
            else:
               // Handle other arguments
      else:
         // No arguments provided
   end

C++

#include <iostream>

int main(int argc, char* argv[]) {
    if (argc > 1) {
        for (int i = 1; i < argc; ++i) {
            if (strcmp(argv[i], "--help") == 0) {
                std::cout << "Help information" << std::endl;
            } else {
                std::cout << "Argument: " << argv[i] << std::endl;
            }
        }
    } else {
        std::cout << "No arguments provided." << std::endl;
    }
    return 0;
}

Python

import sys

def main():
    if len(sys.argv) > 1:
        for arg in sys.argv[1:]:
            if arg == "--help":
                print("Help information")
            else:
                print(f"Argument: {arg}")
    else:
        print("No arguments provided.")

if __name__ == "__main__":
    main()

Java

public class CommandLineArgsExample {
    public static void main(String[] args) {
        if (args.length > 0) {
            for (String arg : args) {
                if (arg.equals("--help")) {
                    System.out.println("Help information");
                } else {
                    System.out.println("Argument: " + arg);
                }
            }
        } else {
            System.out.println("No arguments provided.");
        }
    }
}

Rust

use std::env;

fn main() -> Result<(), std::env::ArgsError> {
    let args: Vec<String> = env::args().collect();

    if args.len() > 1 {
        for arg in &args[1..] {
            if arg == "--help" {
                println!("Help information");
            } else {
                println!("Argument: {}", arg);
            }
        }
    } else {
        println!("No arguments provided.");
    }

    Ok(())
}

Golang

package main

import (
	"fmt"
	"os"
)

func main() {
	args := os.Args[1:] // Exclude the program name

	if len(args) > 0 {
		for _, arg := range args {
			if arg == "--help" {
				fmt.Println("Help information")
			} else {
				fmt.Println("Argument:", arg)
			}
		}
	} else {
		fmt.Println("No arguments provided.")
	}
}

Output

We prompt the user to enter their exam score and compare it with the passing_threshold value of 60. If the exam_score is greater than or equal to 60, the program outputs a success message indicating that the student passed the exam. Otherwise, it prints a message stating that the student did not pass and should try again.

Assume the user enters 75 as input for all the examples.

Since the input 75 is greater than the passing threshold of 60, the output is: `Congratulations! You passed the exam.``.

These respective runtime commands each receive the following output…

// cpp
./a.out arg1 arg2

// python
python script.py arg1 arg2

// java
java CommandLineArgsExample arg1 arg2

// rust
./target/debug/myapp arg1 arg2

// golang
go run script.go arg1 arg2

Argument: arg1
Argument: arg2