Download libcurl

Compiling a Sample SMTP Program with Authentication and Transport Security

g++ smtp-tls.c -o smtp-tls -lcurl

Modifying the Sample to Work with GMail

I modified the following lines in the smtp-tls program to make it work with GMail.

First, I changed the following FROM, TO, CC variables from

#define FROM    "<sender@example.org>"
#define TO      "<addressee@example.net>"
#define CC      "<info@example.org>"

to the following.

#define FROM    "<myemailaddress@gmail.com>"
#define TO      "<myemailaddress@gmail.com>"
#define CC      "<myemailaddress@gmail.com>"

Then I changed the following line setting the URL from

curl_easy_setopt(curl, CURLOPT_URL, "smtp://mainserver.example.net:587");

to the following.

curl_easy_setopt(curl, CURLOPT_URL, "smtp://smtp.gmail.com:587");

I then commented out the following line

//curl_easy_setopt(curl, CURLOPT_CAINFO,"/path/to/certificate.pem");

since I kept receiving errors about certificates and wasn’t sure how to fix this. (If this isn’t done properly, please let me know otherwise!)

Afterwards, I simply put my e-mail address and password

    curl_easy_setopt(curl, CURLOPT_USERNAME, "myemailaddress@gmail.com");
    curl_easy_setopt(curl, CURLOPT_PASSWORD, "PASSWORD123");

The console looked in the following manner:

* About to connect() to smtp.gmail.com port 587 (#0)
*   Trying 74.125.53.109... * connected
* Connected to smtp.gmail.com (74.125.53.109) port 587 (#0)
< 220 mx.google.com ESMTP q10sm8033678pbb.10
> EHLO unknownc42c0304eee8
< 250-mx.google.com at your service, [99.53.224.80]
< 250-SIZE 35882577
< 250-8BITMIME
< 250-STARTTLS
< 250 ENHANCEDSTATUSCODES
> STARTTLS
< 220 2.0.0 Ready to start TLS
* SSL connection using RC4-SHA
* Server certificate:
* 	 subject: C=US; ST=California; L=Mountain View; O=Google Inc; CN=smtp.gmail.com
* 	 start date: 2011-11-18 01:57:17 GMT
* 	 expire date: 2012-11-18 02:07:17 GMT
* 	 common name: smtp.gmail.com (matched)
* 	 issuer: C=US; O=Google Inc; CN=Google Internet Authority
* 	 SSL certificate verify ok.
> EHLO unknownc42c0304eee8
< 250-mx.google.com at your service, [99.53.224.80]
< 250-SIZE 35882577
< 250-8BITMIME
< 250-AUTH LOGIN PLAIN XOAUTH
< 250 ENHANCEDSTATUSCODES
> AUTH PLAIN a3VyaXlha2lAA21haWwuY291AGt1cml5YWtpQGdtYWlsLmNvbQBHTUF0b3MyNzEzdB==
< 235 2.7.0 Accepted
> MAIL FROM:<myemailaddress@gmail.com>
< 250 2.1.0 OK q10sm8033678pbb.10
> RCPT TO:<myemailaddress@gmail.com>
< 250 2.1.5 OK q10sm8033678pbb.10
> RCPT TO:<myemailaddress@gmail.com>
< 250 2.1.5 OK, duplicate recipients will be consolidated. q10sm8033678pbb.10
> DATA
< 354  Go ahead q10sm8033678pbb.10
< 250 2.0.0 OK 1329280154 q10sm8033678pbb.10
* Connection #0 to host smtp.gmail.com left intact
> QUIT
< 221 2.0.0 closing connection q10sm8033678pbb.10
* Closing connection #0

I checked my e-mail, and there it was! If you wish to modify the contents of the e-mail, simply modify the payload.

Let me know if you encountered any problems.

Local Variables

Local variables may be accessed within the block of instructions in which they were declared. For example, when we write a main function, all variables declared in that block of code may be accessed any place after they have been initialized.

1
2
3
4
5
6
7
8
9
10

int main() { 
    int a, b;
    string message = "The sum of a and b is: ";
 
    cin >> a >> b;
 
    cout << message << a + b << endl;
 
    return 0;
}

Variables declared within a block of instructions such as an if-else statement or loop may only be used local to that block as well.

1
2
3
4
5
6
7
8

int n = 10;
int res = 0;
for ( int i = 1; i <= n; i++ ) {
     int a = i*i;
     res += a;
}
 
cout << res << endl;

In the example above, variable a may only be accessed within the for loop.

As you may now know, variables declared within functions are also only local to that function.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

int factorial(int n) {
 
     int factorial = 1;
 
     for ( int i = 1; i <= n; i++ ) { 
          factorial *= i;
     }
 
     return 0;
}
 
int main() { 
    int n;
    cin >> n;
    int fac = factorial(n);
    cout << "Factorial of n: " << fac << endl;
 
    return 0;
}

Global Variables

Global variables on the other hand may be accessed within every scope of the program. The use of global variables is usually discouraged since they may be modified from anywhere. They may be used to avoid having to pass in a variable that remains continuous throughout the program.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include <iostream>
using namespace std;
 
int bonus = 5;
bool flag = false;
 
// This function increases salary and adds the bonus
// if the flag is true
int increaseSalary(int n) { 
    if ( flag ) 
        return n + bonus;
    else 
        return n;
}
 
// This function increases the bonus
void increaseBonus(int n) { 
    bonus += n;
}
 
// This function changes the flag 
void setFlag(bool n) { 
    flag = n;
}
 
int main() {
    cout << "The bonus is currently: " << bonus << endl;
    int mySalary = 10;
    mySalary += increaseSalary(10);
    setFlag(!flag);
    mySalary += increaseSalary(10);
    cout << "My Salary is now: " << mySalary << endl
    return 0;
}

Only use global variables when absolutely needed

Remember, only use global variables if you absolutely need to. It is very cumbersome to debug a program with global variables if several functions are accessing and modifying their values. A good way to use them is possibly for a flag to run auxiliary functions to help decode a program if it its true.

Going further

Now that you understand how the scope of variables work, try answering the following questions.

1. Can two different functions declare variables with the same names?
2. If you declare a variable within the if clause, may you access it in the else clause?
3. If you declare a variable count in an if statement, can you access it within a nested if statement within that original if statement?
4. What is the output up the previous global variable example? What is the value of mySalary?
5. Write a program with a global boolean flag that determines whether to display auxiliary cout statements to help debug your code. (Example: Print out factorial at every iteration.)

return_type name(parameter1, parameter2, ...) 
{
     statements
}

The function is easily broken down into the following parts:

1. The return_type denotes the type of object that the function will return.
2. The name denotes the identifier for the function.
3. The parameters are the inputs for the function. The number of parameters may range from zero or to as many as you need and are separated by commas. The parameters are specified with the type of object and identifier.
4. The statements are the set of instructions executed when the function is called.

Function Example

For example, we could create a function that would return the summation of n. Before functions, we’d have to write the same set of instructions multiple times if we wanted to find the result more than one time. The code is below.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

 
#include <iostream>
 
using namespace std;
 
int summation(int n) {
 
    int total = 0;   
 
    for ( int i = 1; i <= n; i++ ) 
    {
        total += i;
    }
 
    return total;
}
 
int main() {
 
    cout << summation(5) << endl;
 
    return 0;
}

Now, let’s go ahead and break down the previous code.

The following line of code calls the function with a parameter of 5. We could have otherwise done it with an integer variable.

summation(5)

The following is the function header. This function is returning an int value, it’s identifier is summation and it only has one integer parameter n.

int summation(int n) {

Now, we’ll skip the actual calculation of the summation because by this time, you should be able to do these type of problems.

What is interesting is the following statement. It marks the end of the function as it returns an integer variable, total.

return total;

Basic error handling with multiple return statements

We could easily add multiple return statements for different cases of input. One popular case is when the user provided an erroneous input. For example a negative value for our summation function would result in undesired behavior. To prevent this, we could easily add the following before line 8.

if ( n < 0 ) {
    return -1;
}

Why -1? Well, we know by the definition of the sum, n must be 1 or greater. Therefore, if we receive a -1 as an answer, we know the user did something wrong. We could’ve easily added a cout statement letting the user know we didn’t like the previous input. Go ahead, try it.

Error checking is crucial for having programs that run correctly. We don’t want our program to use an invalid sum value if we need it later on do. To fix this, we could either terminate the program or ask the user to provide a valid value again.

Void functions

There are going to be times when we will need a function to simply execute some instructions without returning a value.

For example, let’s create a function that asks the user for his or her name and greets them.

void greeting() {
 
    string name;
    cin >> name;
 
     cout << "Hello, " << name << "!" << endl;
     return;
}

The following function would be called with the following call:

greeting();

If you noticed, this function does not return any type of object. This is a void function.

Going further with functions

In the next tutorial, we’ll talk about the scope of variables. This will teach you about global and local variables within your program.

For now, why don’t you try the following problems?

• Create a factorial function.
• Create a function that adds two integer values together and returns the result

Finish the program described in the tutorial if you haven’t already.

1. Make sure you created the summation function with the error checking described before
2. In your main program, ask the user for an input and determine if it is valid. If it isn’t, ask the user to input another value again.
3. Now, instead of asking the user for input again, simply terminate the program with an error message

Do While Loop

The syntax for the Do While Loop is below:

do { 
 
// Statements ...
 
} while ( condition );

Do While Example

An example of a do while loop is below.

1
2
3
4
5
6
7

string msg;
 
do { 
   cout << "Enter a word or 'exit' to quit: " << endl;
 
   cin >> msg;
} while ( msg != "exit" );

Do While Loops aren’t used as extensively as While Loops and For Loops in practice due to their nature. They are only used for specific cases where the programmer needs the block of statements to be executed at least once.

Going further with Do While Loops

Now that you understand Do While Loops, While Loops, and For Loops why not try the following?

1. Create a factorial program that uses a while, do while, and for loop. Do the same for summation. This should make you fully understand all loops and when to use them.

For loops are different than while loops due to the way they function. This allows one to choose what type of loop to use depending on the problem. For example, while loops are useful for executing statements until a condition is met and a for loop is useful when you know how many iterations you must complete before you get your result.

A for loop works as follows:

1. The variable(s) is initialized
2. The condition is checked. If true, execute statements, else terminate for loop
3. Execute statements within for loop
4. Update variables and return to step B

Diagram of how a for loop works

The syntax is below:

for ( initialization; condition; update) {
 
// statements 
}

For Loop Example

In our previous tutorial, we learned how to count forwards and backwards. In this tutorial, we’ll do something more interesting. We’ll compute the summation from 0 to n, n being user input.

To compute the summation, we simply add up all numbers starting from 0 to n. For example, the sum of 5 would be 0 + 1 + 2 + 3 + 4 + 5 = 15. Taking programming aside, the way we’d solve this step by step would be to have a running sum which we add to until we reach our desired n. Try programming this before you see the solution below.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

int n = 0;  // User input
 
int sum = 0; // Our running sum
 
cout << "Sum: ";
 
cin >> n;
 
// For loop declaration
// We use the variable i to denote an iteration
// In this example, we execute the following loop
// if i is less than or equal to the user input 
for ( int i = 0; i <= n; i++ ) {
 
    sum += i;
 
}

For example, if n was 3, the following loop would execute in the following manner.

i = 0; 0 <= 3
sum += 0;
sum = 0
 
i = 1; 1 <= 3
sum += 1;
sum = 1;
 
i = 2; 2 <= 3
sum += 2
sum = 3
 
i = 3; 3 <= 3
sum += 3
sum = 5
 
i = 4; 4 <= 3
// End of For Loop

For loops advanced

Some things to know about for loops:

• You don’t have to declare a variable within the initialization block of a for loop.
  

  int i; for ( i = 0; i < n; i++ )

• You may have multiple initializations, conditions, and updates if you use a comma in between them.
  

  for ( i = 0, j = 2; i < j; i++ )

• You can break out of a for loop using the following statement:
  

  break;

  This is useful for when you encounter a special case in your loop using if statements.

• Likewise you may use continue; statement.

Going further with For Loops

Now that you understand for loops, why not try the following?

1. Write the previous for loop using a while loop. This will make you understand when to use a for loop
2. Write a for loop that computes the factorial of n.
   

   For example, if n is 3, then the factorial would be fac(3) = 1 x 2 x 3 = 6;

3. Using two for loops (not nested), create a program that draws a triangle.
   

   For example, if n is 3, then the appropriate triangle would be

   *
   **
   ***
   **
   *

4. Using a nested for loop, create a program that will draw a right triangle.
   

   For example, if n is 3, then the appropriate triangle would be

   *
   **
   ***

The While Loop

The while loop is another control flow structure that allows the programmer continuously execute a block of instructions until a specific condition is met. Below is an example of a program that contains a while loop. The idea of the program is for the user to input a variable n, and the while loop will continuously print out and increase n until it is over 100.

Now that you understand the diagram, take a look at the syntax.

while ( condition ) { 
 
     // Statements 
 
}

With the previous diagram, let’s make the program that increases and prints out n until it reaches 100.

In order to become a programmer, its essential that you learn how to create a program based on a specification. So its good to try it out on your own before you look at the solution below.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

 
// Creating and initializing n
int n = 0;
 
// User prompt
cout << "Please enter a number to count to 100: ";
 
 
cin >> n;
 
// Beginning of while loop
while ( n < 100 ) {
 
     // Printing out n
     cout << n << endl;
 
    // Increasing n 
     n = n + 1;
 
} // End of While Loop
 
// Program continues

Going further with While Loops

Now that you learned how to create while loops, let’s have some more practice.

1. Add to the previous program an if statement that determines if the user entered a negative number. If they did, output a message and set n to 0 so it only counts from a positive number to 100.
2. Make a while loop that prints a number from a user inputted n, to 0. If the number is below zero, let the user know, and set n to 100.
3. Using nested while loops, create a program that asks the user for a number from 0 – 10.

   Then print out n stars on one line and print out n number of lines. For example,

   n = 3
   ***
   ***
   ***
   n = 2
   **
   **

Example of Control Flow

Boolean Comparison Operators

Before we teach you how to write these statements, we’ll show you the boolean comparison operators you may use for creating conditions. These condition statements will return either TRUE or FALSE which are useful in if statements.

Operator	Example	Description
>	a > b, a > 2, 4 > 2	Greater than
>=	a >=b, a >= 2, 4 >= 2	Greater than or equal to
<	a < b, a < 2, 4 < 2	Less than
<=	a <= b, a <=2, 4 <= 2	Less than or equal to
==	a == b, 2 == a	Equal to
!=	a != b, 2 != a	Does Not Equal to

You may use these boolean operators to compare data types of similar type. You may compare any of the C++ Data Types with each others whether they are literals such as 2, 3, “Hello”, or variables. If you compare mixed data types you will get different behavior.

Below are some examples of conditions. If they are literals, determine the conditions truth value.

2 < number
 
"Hello" == "HELLO"
 
'a' != 'A'
 
2.0 == 2

You may also use the && (and) and || (or) connectives in order to have multiple conditions. Below is an everyday example and after that some C++ examples.

 
// Returns true if both the 1st and 2nd conditions are true
2 < a && b > c
 
// Returns true if either the 1st or 2nd conditions are true
2 < a || b > c

Finally, you may also use the ! connective to make a condition have the opposite truth value. An example is below:

int a, b;
a = 2;
b = 3;
 
// The following would return TRUE
a < b 
 
// The following would return FALSE because the ! 
// negates the truth value between the parenthesis
! ( a < b )

C++ If Statement

We will now start by showing you the syntax for writing an if statement.

if ( condition ) { 

statements ...

}

Now, we’ll actually put it to some use. In our previous tutorial we learned about user input which will help us make things a lot more interesting. Let’s say we wanted to create a program that asks the user to guess a number and we’ll simply reply if it was the correct one. We’d do it in the following manner.

1
2
3
4
5
6
7
8
9
10
11

int magicNumber = 27;
 
int guess;
 
cout << "Guess my magic number: ";
 
cin >> guess;
 
if ( magicNumber == guess ) {
     cout << "Congratulations! Correct guess!" << endl;
}

In the code above, the statement inside the if clause would execute if the condition were true. Therefore, if the user chooses our magic number 27, our program will congratulate the user.

If Statement Diagram

C++ If Else Statement

Well, what if they didn’t? We would want to give them another message saying it was incorrect. Your first guess might be making another if statement but we can use the else statement.

if ( condition ) { 

statements ...

} else { 

statements ...

}

1
2
3
4
5
6
7

// .. Previous code
 
if ( magicNumber == guess ) {
     cout << "Congratulations! Correct guess!" << endl;
} else { 
    cout << "Incorrect!" << endl;
}

In the previous code, if the user guess the number correctly, the program would congratulate the user. If the user did not guess the number correctly, it would display Incorrect!

If Else Statement

C++ If Else If Else Statement

Now, what if we wanted to actually let them know if their guess was too high or too low if it was incorrect? We can then use the else if statements.

if ( condition ) { 

statements ...

} else if ( condition ) { 

statements ...

} else { 

statements ...

}

1
2
3
4
5
6
7
8
9

// .. Previous code
 
if ( magicNumber == guess ) {
     cout << "Congratulations! Correct guess!" << endl;
} else if ( magicNumber > guess ) {
    cout << "Your guess is too low!" << endl;
} else {
    cout << "Your guess is too high!" << endl;
}

If Else Else If Statements

Nesting If Statements

You may also have nest if statements within if statements. An example is below.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

cin >> guess;
number = 25;
 
if ( number == guess ) {
 
     cout << "Now try guessing the second number!\n";
     // Guess a second number
     number = 56;
     cin >> guess;
 
     if ( number == guess ) { 
         cout << "Congratulations! You guess two numbers correctly!\n";
     } else { 
         cout << "Try next time!\n";
     }
} else { 
    cout << "Incorrect!\n";
}

Overview of If Statements

Some things to know about if statements are mentioned below.

1. Remember, the else statement is optional and you may have zero, one, or more else if statements.
2. For good practice always indent or more formally known as tab your code when its within an if statement. That way it’s easy to follow. Imagine going over nested if statements that don’t have tabs? You would have a hard time figuring out which statements belong where.

   1 2 3 4 5 6 7 8 9 10 11

   if ( a > b ) { if ( c < 2 ) { cout << "Yes!"; } else { cout << "No!"; } } else { cout << "What?"; }

3. If you only have one statement within an if statement you may omit the {}’s. For good practice, just keep them. It’s easier for someone else to go back to read and add to your code.

   1 2 3 4 5 6 7 8

   if ( a == b ) { cout << "Yes!"; }   // Is the same as   if ( a == b ) cout << "Yes!";

Going further with If Statement

Now that you know the basics of If Statements, why not do the following?

1. Create an if statement that contains a condition that is always true.
2. Are “Hello” and “HELLO” equivalent? What about the char ‘a’ and a string “a”?
3. Create a 3rd level deep if statement. The previous example shown was nested 2x.

Keep patient, in our next tutorial we will learn about for loops and then while loops. Once we get a good handle of control flow, we can make some interesting programs.

C++ Standard Output

If you recall, we have been using the cout object to display information on to the screen. Below, I’ll describe various ways to output strings, the contents of variables, expressions, and more.

Basic output with endl

Below is a simple example of printing out the string “Hello, World!” to the terminal accompanied by a newline.

1
2
3
4
5

// We first print out Hello World 
cout << "Hello, World!";
 
// We then add the following to create a new line
cout << endl;

The previous example is demonstrated above.

Basic output with variables

Now, we are going to display the contents of a variable. Notice how we can output more than one item with a single cout object.

1
2
3

int num = 5;
 
cout << num << endl;

Basic output with math expressions

We can also output arithmetic expressions. This by the way, is something you will hardly ever use but its good to know anyways since you’ll always want to save the result of an expression in a variable.

1

cout << 5 * 4 + 3 << endl;

Basic output with boolean expressions

Finally, we will demonstrate a simple example with a boolean expression. This will not print out true or false. It will print out either a 1 for true, or 0 for false. You also need the parenthesis, else the < operator will give you an error.

1

cout << (1 < 3)  << endl;

C++ Standard Input

For standard output we used the object cout and for standard input, we will use the object cin. Before we start with examples, there is are a couple of things you must know.

• User input is usually done through the keyboard and the terminal. Your program will halt at each user input and keep executing when the user enters a value and then presses enter
• The cin object will read in the type of object you tell it to. Therefore, if you wish to have a char, it will read a char. Same with an integer, float, and a string. If you mix things up, you will receive undesired behavior
• The user might provide you with invalid values and therefore require you to do error checking. We will leave this for a later topic.

Reading in a value

Below is an example of reading in a single and multiple values. Try it by changing the object type.

1
2
3
4
5
6
7
8
9
10
11

// We declare and initialize the variable num to -1
int num = -1;
 
// We prompt the user for input
cin >> num;
 
// We declare three strings
string a, b, c;
 
// We read three strings from input
cin >> a >> b >> c;

Going further with input and output

Now that you understand the basics of input and output why not do the following?

1. Prompt the user for his First Name, Last Name, Age, City, and State in the following fashion.

   Enter your first name:
   Enter your last name:
   Enter your age:
   Enter your city:
   Enter your state:

   
   
   Then, output the results in the following fashion.

   Hello firstname lastname! 
   I see you are age years old and live in city, state.

2. Now try declaring a variable without initializing it. Then output it. What happened?
3. Try reading in an int value, but give it a string. Output the variable and what happens?

C++ String

The string class represents what you may know as a string of text. Remember our previous C++ Hello World program? Well, you can also think of the output to the terminal as a string of text.

Below is some simple usage of the string class:

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>
 
using namespace std;
 
int main() { 
 
    string message;
    message = "Hello World!";
 
    cout << message << endl;
    return 0;
}

The output of course, would be a simple “Hello World!” to the console ending with a newline.

String class functions

Until now, we haven’t discussed much about functions. We’ll discuss them in more detail later, but for now just know that functions provide us more functionality with a data type. We’ll only be discussing functions that either modify or access more information about a data type.

For example, think of it as a black box. You provide it an object, lets say a car, and you provide some input such as color of the car, type of engine you want, and other options. Well, this function (our black box) would return a car modified to your inputs.

The beauty of functions, is that you don’t need to know what happens internally! You simply provide the object and inputs if necessary, and you should receive your desired output. We’ll discuss later how to create our own functions.

In order to call a function, you simply specify the identifier , function name, and input parameters if necessary. Follow the examples provided below and you’ll understand. We’ll be continuing the previous usage example, so feel free to keep adding to your program.

For the following functions, take into consideration how the string is stored. This will help you in understanding the following functions.

The image above displays the indices of the characters starting at position 0.

length()

1
2
3
4
5

// Stores the size of our message in an int value
int size = message.length();
 
// The result will be 12. A space is counted as a character.
cout << size << endl;

substr()

1
2
3
4
5

// Generates a substring of size 5, starting at position 2
string substring = message.substr(2,5);
 
// The result is "llo W"
cout << substring << endl;

operator+

1
2
3
4
5
6
7

string a = "Hello ";
string b = "World!";
 
string c = a + b;
 
// Will display "Hello World!";
cout << c << endl;

The best way to learn how to use strings, is by using them.

Going further with the String class

Now that you understand the basics of strings why not do the following?

1. Develop a program that contains your first and last name in two respective variables called first and last.

   Concatenate your first and last name to create another variable, fullname.

   Now, using the substr function, separate both your first and last name from the fullname variable.

   For example this should be the output:

   1 2 3 4 5 6

   First name(first): Diego Last name(last): Villasenor Full name(fullname): Diego Villasenor   First using substr(fullname): Diego Last using substr(fullname): Villasenor

C++ Variables

Variables are created through the use of identifiers. An identifier is a sequence of one or more digits, letters, or the underscore character. It also may not be a reserved word, have two consecutive underscores, or begin with a digit. A reserved word is simply a keyword that is reserved by the language such as: int, double, string.

Below, is an example of the creation and manipulation of variables.

1
2
3
4
5
6
7

// Below we are creating two different variables of type int
int num = 5;
int num2 = 10;
 
// Below we are creating a variable of type in that stores the sum of the 
// previous two variables.
int sum = num + num2;

C++ Fundamental Data Types

For now, we will discuss a couple of the fundamental data types the C++ language has to offer. Later, we’ll learn how to create our own through the use of classes.

Declaring variables

In order to declare a variable, you need to specify the type of variable, identifier, and initialize it if you wish. Below are a couple of examples.

1
2
3
4
5
6
7
8
9
10
11
12
13

// Declaring and initializing variables differently
int num1 = 5;
double num2;
num2 = 2.5;
 
// Declaring a list of variables
int a, b, c, d;
 
// Setting a boolean value
bool val = true;
 
// When you declare a character, you need to use the ''s
char e = 'b';

Some things to take into consideration are below:

• Uninitialized variables is a bad practice. If you forget, and try to use them later throughout your program they will contain garbage and will lead to undefined behavior for your program

Example of C++ Program with Variables

Below is a simple example of a program that uses what we just learned. Try it out for yourself and try new things as well.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <iostream>
 
using namespace std;
 
int main() { 
 
     //Outputs to the terminal, followed by a newline character
     cout << "Welcome!\n";
 
     // Declaring some variables and initializing them
     int a, b, c;
     a = 3;
     b = 2;
     c = a + b;
 
     // Outputting c to the terminal as well as a new line
     cout << "The sum of a and b is: " << c << endl;
 
     return 0;

Further practice

You need further practice? Don’t worry, in the next few tutorials, we’ll learn how to use the different variable types you learned today. Just as long as you understand the material in this tutorial you are doing fine. Have any questions? Post them below.

In the next tutorial, we’ll be learning about global and constant variables as well as the scope of variables.