Programming/C++/Syntax - Revision history

Brodriguez: Brodriguez moved page C++/Syntax to Programming/C++/Syntax

2023-04-21T03:57:03Z

Brodriguez moved page C++/Syntax to Programming/C++/Syntax

← Older revision

Revision as of 03:57, 21 April 2023

Brodriguez: Add notes about function templating

2023-03-06T10:58:20Z

Add notes about function templating

← Older revision		Revision as of 10:58, 6 March 2023
Line 203:		Line 203:

	{{ note \|C++ requires the args be properly defined, to match the actual args of the function itself. However, some C compilers are more loose with rules, and it's possible to skip the args entirely in the function declaration. It will still work.}}		{{ note \|C++ requires the args be properly defined, to match the actual args of the function itself. However, some C compilers are more loose with rules, and it's possible to skip the args entirely in the function declaration. It will still work.}}


			=== Function Overloading ===

			If two functions are very similar, then we can do function overloading.

			For example, what if we want a function that can take either an {{ ic \|int}} or a {{ ic \|double}} as a parameter, and then otherwise handle the same?

			All you do is [[ Programming/C++/Syntax#Function_Definitions \| define]] the same function twice. As long as each either has different parameter typings, or a different number of parameters, then this is allowed.

			Ex:
			# In this case, we can call the same function name and pass in two different possible variable types.
			void my_number_processor(int num) {
			# Do stuff here.
			}
			void my_number_processor(double num) {
			# Do stuff here.
			}

			=== Function Templating ===

			In a similar vein of logic to [[ Programming/C++/Syntax#Function_Overloading \| Function Overloading]], we have '''Function Templates'''. In fact, templates are arguably even more useful.

			Rather than having to declare the entire function twice (or more, if we overload it more than two times), templates allow us to declare the function exactly once, and still get the same effect.

			{{ note \| Compared to function overloading, function templating is often slower to compile, but faster in execution time. }}

			To declare a template, we have to put the entire function in a header file.
			{{ hc \|my_file.hpp\|<nowiki>
			template <typename T>
			<return_type> <function_name>(T <arg>) {
			# Do stuff here.
			# Note that our passed "<arg>" variable can now be any type.

			...
			}
			</nowiki>}}

			Ex:
			{{ hc \|my_file.hpp\|<nowiki>
			template <typename T>
			void my_function(T item) {
			# Do stuff here.
			# Note that our passed "item" variable can now be any type.

			...
			}
			</nowiki>}}

Brodriguez: Add extension type

2023-03-06T09:58:56Z

Add extension type

← Older revision		Revision as of 09:58, 6 March 2023
Line 1:		Line 1:
	{{ Note \| Common File Extensions: {{ ic \|.cpp}} {{ ic \|.h}} }}		{{ Note \| Common File Extensions: {{ ic \|.cpp}} {{ ic \|.h}} {{ ic \|.hpp}} }}

Brodriguez: Correct some formatting

2023-03-06T09:51:54Z

Correct some formatting

← Older revision		Revision as of 09:51, 6 March 2023
Line 166:		Line 166:
	# Function logic here.		# Function logic here.
	}		}

	# This is a function that returns an int.		# This is a function that returns an int.
	int my_function() {		int my_function() {
Line 174:		Line 174:

	int my_return_int = 5;		int my_return_int = 5;

	...		...

	return my_return_int;		return my_return_int;
	}		}

	# This is a function that returns nothing, but takes three parameters.		# This is a function that returns nothing, but takes three parameters.
	void my_function(int my_int, std::string my_string, bool some_other_arg) {		void my_function(int my_int, std::string my_string, bool some_other_arg) {

Brodriguez: Add function declaration section

2023-03-06T09:35:56Z

Add function declaration section

@@ Line 153: / Line 153: @@
 == Functions ==
   <return_type> <function_name>(<arg1>, <arg2>, ..., <argn>) {
@@ Line 182: / Line 184: @@
       # Function logic here.
+  }

Brodriguez: Export some sections

2023-03-06T04:35:18Z

Export some sections

← Older revision		Revision as of 04:35, 6 March 2023
Line 1:		Line 1:
	{{ Note \| Common File Extensions: {{ ic \|.cpp}} {{ ic \|.h}} }}		{{ Note \| Common File Extensions: {{ ic \|.cpp}} {{ ic \|.h}} }}


	~~== Compiling C++ ==~~
	~~To run any C++ code, it must first be compiled.~~

	~~To do this, in terminal, cd to the desired directory and run {{ ic \|g++ <path_to_file> -o <name_of_file_to_create>}}.~~

	~~This will generate a new executable file, based on the compiled code.<br>~~
	~~Run this file via {{ ic \|./<name_of_created_file>}}.~~


	~~== Types of Errors ==~~

	* Compile Time Errors - Errors that happen during file compile.
	** Syntax Errors - Errors that happen from incorrect typed syntax for the given language.
	** Type Errors - Errors that happen due to mismatch of declared type and attempted type usage.
	* Link Time Errors - Errors that happen when trying to combine compiled files into a single executable program.
	** Ex: Using a function that was never defined, or {{ ic \|Main()}} instead of {{ ic \|main()}.
	* Run Time Errors - Errors that happen during program execution.
	** Ex: Divide-by-zero errors, or attempting to open a file mid-runtime and said file doesn't exist.
	* Logic Errors - Soft errors that don't cause an actual crash. But can cause a program soft-lock, or general unintended behavior.

Brodriguez: Add function section

2023-03-06T03:40:01Z

Add function section

← Older revision		Revision as of 03:40, 6 March 2023
Line 174:		Line 174:

	== Functions ==		== Functions ==

			<return_type> <function_name>(<arg1>, <arg2>, ..., <argn>) {
			# Function logic here.
			return <return_value>;
			}

			Ex:
			# This is a function that returns nothing.
			void my_function() {
			# Function logic here.
			}

			# This is a function that returns an int.
			int my_function() {
			# Function logic here.

			...

			int my_return_int = 5;

			...

			return my_return_int;
			}

			# This is a function that returns nothing, but takes three parameters.
			void my_function(int my_int, std::string my_string, bool some_other_arg) {
			# Function logic here.
			}

Brodriguez: Brodriguez moved page C++ to C++/Syntax

2023-03-06T01:46:34Z

Brodriguez moved page C++ to C++/Syntax

← Older revision

Revision as of 01:46, 6 March 2023

Brodriguez: Expand page

2023-03-06T01:46:11Z

Expand page

@@ Line 9: / Line 9: @@
 This will generate a new executable file, based on the compiled code.<br>
 Run this file via {{ ic |./<name_of_created_file>}}.
@@ Line 103: / Line 115: @@
 == If Statements ==
 == Functions ==

Brodriguez: Create page

2023-02-21T08:24:12Z

Create page

New page

{{ Note | Common File Extensions: {{ ic |.cpp}} {{ ic |.h}} }}

== Compiling C++ ==
To run any C++ code, it must first be compiled.

To do this, in terminal, cd to the desired directory and run {{ ic |g++ <path_to_file> -o <name_of_file_to_create>}}.

This will generate a new executable file, based on the compiled code.<br>
Run this file via {{ ic |./<name_of_created_file>}}.

== Comments ==

=== Inline Comments ===
// This is an inline comment.

=== Block Comments ===
/**
*This is a block comment.
*Comment line 2.
*Another block comment line.
*/

== Basic Input and Output ==

=== Basic Output ===

A very basic output example is:
#include <iostream>

std::cout << "Hello World!\n";

We can also chain together strings this way:
#include <iostream>

std::cout << "Hello " << "World!" << "\n";

If we exclude the {{ ic |\n}}, then output will remain on a single line:
#include <iostream>

std::cout << "Hello ";
std::cout << "World!";
std::cout << "\n";

The above code snippets are all functionally equivalent.

=== Basic Input ===

Similar to basic output:
#include <iostream>

std::cin >> <variable_here>

For example:
#include <iostream>

// This will read in a string as a variable, then immediately display it.
string my_string;
std::cin >> my_string;
std::cout << my_string << "\n";

== Variables ==
Variables are strongly typed in C++. That means you must declare the type as well as the name.

=== Variable Definition ===
bool a_bool = true;
bool b_bool = false;
string my_var_1 = "This is ";
string my_var_2 = "a string.";

=== Variable Usage ===
#include <iostream>

std::cout << "Printing variable values.\n";
std::cout << a_bool << "\n";
std::cout << b_bool << "\n";
std::cout << my_var_1 << my_var_2 << "\n";

=== Booleans ===
C++ uses the following bools"

bool true_bool = true;
bool false_bool = false;

=== Null Values ===
C++ uses the standard {{ ic |null}}.

int null_value = null;

== Import Statements ==

== If Statements ==

== Functions ==