Copy_of_Basic_of_C++.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/YujieChi/Cuda-Google-Colab/blob/main/Copy_of_Basic_of_C%2B%2B.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!nvcc --version"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wY-g8lja-oAC",
        "outputId": "c686bcee-eba3-4fd2-aa35-5609c094a802"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "nvcc: NVIDIA (R) Cuda compiler driver\n",
            "Copyright (c) 2005-2023 NVIDIA Corporation\n",
            "Built on Tue_Aug_15_22:02:13_PDT_2023\n",
            "Cuda compilation tools, release 12.2, V12.2.140\n",
            "Build cuda_12.2.r12.2/compiler.33191640_0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3_8odoHmArJr"
      },
      "source": [
        "#**Introduction**\n",
        "\n",
        "C++ (pronounced see plus plus) is a general purpose programming language that is free-form and compiled. It is regarded as an intermediate-level language, as it comprises both high-level and low-level language features. It provides imperative, object-oriented and generic programming features.\n",
        "\n",
        "C++ is one of the most popular programming languages and is implemented on a wide variety of hardware and operating system platforms. As an efficient performance driven programming language it is used in systems software, application software, device drivers, embedded software, high-performance server and client applications, and entertainment software such as video games. Various entities provide both open source and proprietary C++ compiler software, including the FSF, LLVM, Microsoft and Intel\n",
        "\n",
        "**What is C++**\n",
        "C++ is a cross-platform language that can be used to create high-performance applications.\n",
        "\n",
        "**Who developed C++**\n",
        "C++ was developed by Bjarne Stroustrup.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g6LT91r5_mdJ"
      },
      "source": [
        "#1- **Hellow Words**\n",
        "Every C++ program uses libraries, which give the ability to execute necessary functions. For example, the most basic function called 'cout', which prints to the screen, is defined in the iostream header file.\n",
        "\n",
        "To add the ability to run the cout command to our program, we must add following include directive to our first line of the code:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "am4ZQ3cN_Bc_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "93e6cfd1-d182-44e2-8fc5-65d73c008661"
      },
      "source": [
        "# Write a cu file\n",
        "%%writefile hello.cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main() {\n",
        "  cout << \"Goodbye, World!\" << std::endl;\n",
        "  return 0;\n",
        "}"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing hello.cu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Compilation"
      ],
      "metadata": {
        "id": "0aolkClA-URh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!nvcc hello.cu -o hello"
      ],
      "metadata": {
        "id": "hGo4wRt3-XOx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Run the code"
      ],
      "metadata": {
        "id": "O96VgOdw_K31"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!./hello"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E5SM8uLH_M8s",
        "outputId": "f03d296b-2d24-43ac-f9bd-27c2d85d1de7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Goodbye, World!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "03I1mZizzX5x"
      },
      "source": [
        "#2-**Comments**\n",
        "Comments can be used to explain C++ code, and to make it more readable. It can also be used to prevent execution when testing alternative code. Comments can be singled-lined or multi-lined.\n",
        "\n",
        "Single-line comments start with two forward slashes (//).\n",
        "\n",
        "Any text between // and the end of the line is ignored by the compiler (will not be executed).\n",
        "\n",
        "This example uses a single-line comment before a line of code:\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dNCM9_GN0IFf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "472f1176-5f2d-4c79-973a-ad2d527779d3"
      },
      "source": [
        "# Write a cu file\n",
        "%%writefile hello.cu\n",
        "/* hellow wors\n",
        "sdfdf\n",
        "*/\n",
        "#include <iostream>\n",
        "using namespace std; // it used for explaination\n",
        "\n",
        "int main() {\n",
        "  cout << \"Goodbye, World!\" << std::endl;\n",
        "  return 0;\n",
        "}"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting hello.cu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9nJmmu7VDI-8"
      },
      "source": [
        "#3-**C++ User Input**\n",
        "\n",
        ".You have already learned that cout is used to output (print) values. Now we will use cin to get user input.\n",
        "\n",
        ".cin is a predefined variable that reads data from the keyboard with the extraction operator (>>)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cI_PlqEbB7EG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d9df0e24-034b-4cb9-9be5-3062bc6be1df"
      },
      "source": [
        "# Write a cu file\n",
        "%%writefile hello.cu\n",
        "\n",
        "#include <iostream>\n",
        "using namespace std; // it used for explaination\n",
        "\n",
        "int main() {\n",
        "  int x=0;\n",
        "cout << \"Type a number: \"; // Type a number and press enter\n",
        "cin >> x; // Get user input from the keyboard\n",
        "cout << \"Your number is: \" << x; // Display the input value\n",
        "}"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting hello.cu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BYz7t5-DFgLd"
      },
      "source": [
        "#4-**Variable and types**\n",
        "\n",
        "**Data types**\n",
        "\n",
        "C++ provides a rich set of built-in as well as user defined data types. Following table lists down seven basic C++ data types:\n",
        "\n",
        "**Built-in**\n",
        "- Boolean - boolean - either true or false (Size 4 bytes).\n",
        "- Integers - whole numbers which can be both positive and negative. Defined using char, int.(Size 4 bytes)\n",
        "- Floating point numbers - real numbers (numbers with - fractions). Defined using float and double (Size 4 bytes)\n",
        "- Double - Stores Fractional numbers.Containing one or more decimals (size 8 bytes )\n",
        "- Char - Stores a Single Characters\n",
        "Valueless using the void keyword\n",
        "Wide character using the wchar_t keyword(Size 1 bytes)\n",
        "\n",
        "**Typdefs**\n",
        "Typedefs allow for creating new names (think of them as aliases) for existing types. Following is the simple syntax to define a new type using typedef:\n",
        "\n",
        "**Defining variables**\n",
        "For numbers, we will usually use the type int, which an integer in the size of a \"word\" the default number size of the machine which your program is compiled on. On most computers today, it is a 32-bit number, which means the number can range from -2,147,483,648 to 2,147,483,647 (same as long).\n",
        "\n",
        "To define the variables foo and bar, we need to use the following syntax:\n",
        "\n",
        "int foo;\n",
        "\n",
        "int bar = 1;\n",
        "\n",
        "The variable foo can be used, but since we did not initialize it, we don't know what's in it. The variable bar contains the number 1.\n",
        "\n",
        "Now, we can do some math. Assuming a, b, c, d, and e are variables, we can simply use plus, minus and multiplication operators in the following notation, and assign a new value to a:\n",
        "\n",
        "int a = 0, b = 1, c = 2, d = 3, e = 4;\n",
        "\n",
        "a = b - c + d * e;\n",
        "\n",
        "cout << a << endl; // will print 1-2+3*4 = 11\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wlbWsYAQqGjm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f3c2ade2-ab2b-48cb-eae5-07588a17b92a"
      },
      "source": [
        "# Write a cu file\n",
        "%%writefile sum.cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main() {\n",
        "  int a = 3;\n",
        "  float b = 4.5;\n",
        "  double c = 5.75;\n",
        "  int sum;\n",
        "\n",
        "  /* Your code goes here */\n",
        "    sum =a+b+c;\n",
        "\n",
        "  cout << \"The sum of a, b, and c is\" << sum << endl;\n",
        "  return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting sum.cu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Compilation"
      ],
      "metadata": {
        "id": "eogdSu5CWVEe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!nvcc sum.cu -o sum1"
      ],
      "metadata": {
        "id": "YgkH4tLwWXDG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "execution"
      ],
      "metadata": {
        "id": "huB9xrg_Wgaf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!./sum1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_jWwK_f-Wh6k",
        "outputId": "de06c561-e6cd-4595-8aaf-7682b28295de"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The sum of a, b, and c is13\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_y1-oaL4DmST",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9f5d1bc7-f464-4ef7-c59c-c28fd221521c"
      },
      "source": [
        "# Write a cu file\n",
        "%%writefile hello.cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main () {\n",
        "  int myNum = 1000;\n",
        "  cout << myNum;\n",
        "  return 0;\n",
        "}\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting hello.cu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6MCMxpNOFLsM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0a491588-d3e4-4db1-d479-1f69728b5d1d"
      },
      "source": [
        "# Write a cu file\n",
        "%%writefile hello.cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "    float mynumb=2.25;\n",
        "    cout <<mynumb;\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting hello.cu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dnOb80WmhpEP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d7ca6172-2d82-470e-bd5a-7358527eb65e"
      },
      "source": [
        "# Write a cu file\n",
        "%%!\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "    double mynumb=66.87;\n",
        "    cout <<mynumb;\n",
        "    return 0;\n",
        "\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['/bin/bash: line 2: using: command not found',\n",
              " \"/bin/bash: -c: line 4: syntax error near unexpected token `('\",\n",
              " \"/bin/bash: -c: line 4: `int main(){'\"]"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gRMWj0ubYmlC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2893f8e2-36da-4f5b-8387-c2c7b5f7c644"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namesapace std;\n",
        "\n",
        "int main() {\n",
        "  int x = 5;\n",
        "  int y = 3;\n",
        "  cout << x + y;\n",
        "  return 0;\n",
        "}\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "UsageError: Cell magic `%%cu` not found.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "niOqrXYirLI0"
      },
      "source": [
        "##4.1**-Strings**\n",
        "Strings are used for storing text.\n",
        "\n",
        "A string variable contains a collection of characters surrounded by double quotes\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3e4il_SbHlGa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "baa080e7-d722-403d-db87-b7abfe88e7f3"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "    string shahzad = \"hello\";\n",
        "    cout << shahzad;\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OV7wWFvR7tSO"
      },
      "source": [
        "# 5-**C++ Operators**\n",
        "Operators are used to perform operations on variables and values.\n",
        "\n",
        "In the example below, we use the + operator to add together two values:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ib_1YEkT9RSD"
      },
      "source": [
        "## 5.1**Arithmetic Operators**\n",
        "Arithmetic operators are used to perform common mathematical operations.\n",
        "\n",
        ".(+)  (Addition) \t(Adds together two values)  \t(x + y)\n",
        "\n",
        ".(-) \t(Subtraction)\t(Subtracts one value from another)\t(x - y)\n",
        "\n",
        ".(*) (Multiplication) \t(Multiplies two values) \t(x * y)\n",
        "\n",
        ".(/) \t(Division) \t(Divides one value by another) \t(x / y)\n",
        "\n",
        ".(%) \t(Modulus) \t(Returns the division remainder) \t(x % y)\n",
        "\n",
        ".(++) \t(Increment) \t(Increases the value of a variable by 1) \t(++x)\n",
        "\n",
        ".(--) \t(Decrement) \t(Decreases the value of a variable by 1) \t(--x)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QF_Q5Y-j9FNt"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "    int a = 7;\n",
        "    int b = 6;\n",
        "    int resultplus;\n",
        "    resultplus=a+b;\n",
        "    int resultminus;\n",
        "    resultminus=a-b;\n",
        "    int resultmultiplaction;\n",
        "    resultmultiplaction=a*b;\n",
        "    int resultdivision;\n",
        "    resultdivision=a/b;\n",
        "    cout <<\"additiona+b=\"<<resultplus<<endl;\n",
        "    cout <<\"minusa-b=\"<<resultminus<<endl;\n",
        "    cout <<\"resultmultiplactiona*b=\"<<resultmultiplaction<<endl;\n",
        "    cout <<\"divisiona/b=\"<<resultdivision<<endl;\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "36_WDdfkG1si"
      },
      "source": [
        "#**5.2Assignment Operators**\n",
        "\n",
        "Assignment operators are used to assign values to variables.\n",
        "\n",
        "In the example below, we use the assignment operator (=) to assign the value 10 to a variable called x:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YGtKt_nMHE9b"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "    int a; // this is definition of assignment\n",
        "    a = 2; //\n",
        "    cout <<a<<endl;\n",
        "    return 0;\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4mT7mGDzPAj4"
      },
      "source": [
        "## 5.3**Comparison Operators**\n",
        "\n",
        "Comparison operators are used to compare two values.\n",
        "\n",
        "Note: The return value of a comparison is either true (1) or false (0).\n",
        "\n",
        "In the following example, we use the greater than operator (>) to find out if 5 is greater than 3:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2TozvDFGXyTG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "05432e0e-3f73-4d78-d735-a8b0d372bf5c"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "    int a =5;\n",
        "    int b =4;\n",
        "    cout <<(a>b)<<endl;\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "UsageError: Cell magic `%%cu` not found.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3puBIFAu5rxI"
      },
      "source": [
        "##5.4**Logical Operators**\n",
        "Logical operators are used to determine the logic between variables or values:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xRu7fBW06M60"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "    int a=3;\n",
        "    int b=5;\n",
        "    cout <<(a>3 && a<7)<<endl; // returns true (1) because 3 is greater than 2 AND 2 is less than 3\n",
        "    cout <<(b>3 || b<4)<<endl; // returns true (1) because one of the conditions are true (5 is greater than 3, but 5 is not less than 4)\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oNfn7srVI-Dm"
      },
      "source": [
        "#6-**C++ Math**\n",
        "C++ has many functions that allows you to perform mathematical tasks on numbers.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s_3xpRurJT0U"
      },
      "source": [
        "##6.1-**Max and min**\n",
        "The max(x,y) function can be used to find the highest value of x and y:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cltZ1_XZJrn1"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "    int a;\n",
        "    a = 2;\n",
        "    int b;\n",
        "    b = 5;\n",
        "    cout <<max(a,b)<<endl; // this function is used to find max value between two\n",
        "    // value\n",
        "    cout <<min(a,b)<<endl; // this function is used to find min values beteen\n",
        "   // two  value\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "St_cU5xGL37Y"
      },
      "source": [
        "##6.2-**math Header**\n",
        "Other functions, such as sqrt (square root), round (rounds a number) and log (natural logarithm), can be found in the <cmath> header file:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jy6B6PNlMQMo"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "#include <cmath>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "    int a;\n",
        "    a = 4;\n",
        "    int b;\n",
        "    b = -2;\n",
        "    cout <<\"square value of a=\"<<sqrt(a)<<endl; // sqrt function is used to find squar root of varia\n",
        "    cout <<\"absolate vale of b=\"<<abs(b)<<endl;\n",
        "}\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XO3Vd6AoP_Fd"
      },
      "source": [
        "#7-**C++ Booleans**\n",
        "Very often, in programming, you will need a data type that can only have one of two values, like:\n",
        "\n",
        "YES / NO\n",
        "\n",
        "ON / OFF\n",
        "\n",
        "TRUE / FALSE\n",
        "\n",
        "\n",
        "For this, C++ has a bool data type, which can take the values true (1) or false (0).\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xU-JYtJvQ6A-",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        },
        "outputId": "8a3fd428-5948-4ccf-a149-50420db756f9"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "    bool a =true;\n",
        "    bool b =false;\n",
        "    cout <<a<<endl;\n",
        "    cout <<b<<endl;\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "0\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wmABHxPm9y04"
      },
      "source": [
        "##**7.1-Boolean Expression**\n",
        "A Boolean expression is a C++ expression that returns a boolean value: 1 (true) or 0 (false).\n",
        "\n",
        "You can use a comparison operator, such as the greater than (>) operator to find out if an expression (or a variable) is true:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OtKusYp5_xcn",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "outputId": "d7a4f654-0626-4d5c-c4ce-8d72ea1ce7dc"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "           int a;\n",
        "           a = 2;\n",
        "           int b;\n",
        "           b = 1;\n",
        "           cout <<\"true and false\"<<(a>b)<<endl;\n",
        "           return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "true and false1\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Eg5xpduAiJT"
      },
      "source": [
        "#**8-C++ Conditions and If Statements**\n",
        "C++ supports the usual logical conditions from mathematics:\n",
        "\n",
        "- Less than: a < b\n",
        "- Less than or equal to: a <= b\n",
        "- Greater than: a > b\n",
        "- Greater than or equal to: a >= b\n",
        "- Equal to a == b\n",
        "- Not Equal to: a != b\n",
        "- You can use these conditions to perform different actions for different decisions.\n",
        "\n",
        "C++ has the following conditional statements:\n",
        "\n",
        "- Use if to specify a block of code to be executed, if a specified condition is true\n",
        "- Use else to specify a block of code to be executed, if the same condition is false\n",
        "- Use else if to specify a new condition to test, if the first condition is false\n",
        "- Use switch to specify many alternative blocks of code to be executed\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HKZNKovpDNIN"
      },
      "source": [
        "##**8.1-The if Statement**\n",
        "Use the if statement to specify a block of C++ code to be executed if a condition is true."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NgeDTZNBDv5V"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "    if (5>10) {\n",
        "        cout <<\"20 is greater than 10\"<<endl;\n",
        "    }\n",
        "    cout <<\"main body exution\"<<endl;\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_dL_5TeTfCJO"
      },
      "source": [
        "##**-8.2The else Statement**\n",
        "Use the else statement to specify a block of code to be executed if the condition is false."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uky0BQRTfdip"
      },
      "source": [
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main() {\n",
        "  int time = 20;\n",
        "  if (time < 18) {\n",
        "    cout << \"Good day.\";\n",
        "  } else {\n",
        "    cout << \"Good evening.\";\n",
        "  }\n",
        "  return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "trLHD6JAfhmM"
      },
      "source": [
        "##**8.3-The else if Statement**\n",
        "Use the else if statement to specify a new condition if the first condition is false."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lXIGAjKrfxN2"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main() {\n",
        "  int time = 22;\n",
        "  if (time < 10) {\n",
        "    cout << \"Good morning.\";\n",
        "  } else if (time < 20) {\n",
        "    cout << \"Good day.\";\n",
        "  } else {\n",
        "    cout << \"Good evening.\";\n",
        "  }\n",
        "  return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rd-BT8dqkJA-"
      },
      "source": [
        "#**9-C++ Switch Statements**\n",
        "Use the switch statement to select one of many code blocks to be executed.\n",
        "This is how it works:\n",
        "-  The switch expression is evaluated once\n",
        "- The value of the expression is compared with the values of each case\n",
        "- If there is a match, the associated block of code is executed\n",
        "- The break and default keywords are optional, and will be described later in this chapter"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N8cezjiflVKM"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "    int day=9;\n",
        "    switch(day){\n",
        "     case 1:\n",
        "     cout <<\"monday\";\n",
        "     break;\n",
        "     case 2:\n",
        "     cout <<\"tuesday\";\n",
        "     break;\n",
        "     default:\n",
        "     cout <<\"no case matches\";\n",
        "    }\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XjWGTtdroFAd"
      },
      "source": [
        "**The break Keyword**\n",
        "\n",
        "When C++ reaches a break keyword, it breaks out of the switch block.\n",
        "\n",
        "This will stop the execution of more code and case testing inside the block.\n",
        "\n",
        "When a match is found, and the job is done, it's time for a break. There is no need for more testing.\n",
        "\n",
        "A break can save a lot of execution time because it \"ignores\" the execution of all the rest of the code in the switch block."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wfRMqaU0oVQn"
      },
      "source": [
        "**The default Keyword**\n",
        "\n",
        "The default keyword specifies some code to run if there is no case match:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IttS4YpGrBVI"
      },
      "source": [
        "#**10-Loop**\n",
        "Loops can execute a block of code as long as a specified condition is reached.\n",
        "\n",
        "Loops are handy because they save time, reduce errors, and they make code more readable.\n",
        "\n",
        "**While Loop**\n",
        "\n",
        "The while loop loops through a block of code as long as a specified condition is true:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NFC8Fw2VtL0R"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "    int i =0;\n",
        "    while (i<5){\n",
        "        cout <<\"shahzad\"<<\"\\n\";\n",
        "        i++;\n",
        "    }\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E4oJNt3SIO4c"
      },
      "source": [
        "##**10.1-The Do/While Loop**\n",
        " - The do/while loop is a variant of the while loop.\n",
        " -This loop will execute the code block once, before checking if the condition is true, then it will repeat the loop as long as the condition is true."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mxXHBJCbI0Oc"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "    int i =9;\n",
        "    do{\n",
        "        cout <<\"shahzad\"<<\"\\n\";\n",
        "       i++;\n",
        "    }\n",
        "    while(i<5);\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zaDvDhvw34f0"
      },
      "source": [
        "##**10.2-C++ Break**\n",
        "The break statement can also be used to jump out of a loop.\n",
        "\n",
        "This example jumps out of the loop when i is equal to 4:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mjFnE38z8wI1"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "     for (int i = 0; i < 14; i++) {\n",
        "         if (i == 8){\n",
        "          break;\n",
        "         }\n",
        "    cout << i << \"\\n\";\n",
        "  }\n",
        "  return 0;\n",
        "}\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wFFSI7LWLKkv"
      },
      "source": [
        "##**10.3-C++ Continue**\n",
        "\n",
        "The continue statement breaks one iteration (in the loop), if a specified condition occurs, and continues with the next iteration in the loop."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mdZScBZ1NN2A"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main(){\n",
        "    for (int i = 0; i < 12; i++) {\n",
        "        if (i == 7){\n",
        "            continue;\n",
        "        }\n",
        "        cout <<i<<\"\\n\";\n",
        "    }\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sUO8mXnI1CQ4"
      },
      "source": [
        "#**11-C++ Arrays**\n",
        "Arrays are used to store multiple values in a single variable, instead of declaring separate variables for each value.\n",
        "\n",
        "To declare an array, define the variable type, specify the name of the array followed by square brackets and specify the number of elements it should store:\n",
        "\n",
        "**string cars[4];**\n",
        "\n",
        "To create an array of three integers, you could write:\n",
        "**int myNum[3] = {10, 20, 30};**\n",
        "\n",
        "**Access the Elements of an Array**\n",
        "\n",
        "You access an array element by referring to the index number.\n",
        "\n",
        "This statement accesses the value of the first element in cars:\n",
        "\n",
        "string cars[4] = {\"Volvo\", \"BMW\", \"Ford\", \"Mazda\"};\n",
        "cout << cars[0];\n",
        "// Outputs Volvo"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iVAce0oW2QfL"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "#include <string>\n",
        "using namespace std;\n",
        "\n",
        "int main() {\n",
        "    string Ali[4] = {\"ijaz\",\"hussain\", \"book\", \"work\"};\n",
        "    cout <<Ali[0];\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QNKJaeYNBSTl"
      },
      "source": [
        "**Change an Array Element**\n",
        "\n",
        "To change the value of a specific element, refer to the index number:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "40LhMn96BoJt"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main() {\n",
        "    string hussain[4] = {\"ali\",\"abbas\",\"summar\",\"ayan\"};\n",
        "    hussain[0]=\"haya\";\n",
        "    cout <<hussain[0];\n",
        "    return 0;\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vtTDrlMQDBZh"
      },
      "source": [
        "##**11.1-C++ Arrays and Loops**\n",
        "\n",
        "You can loop through the array elements with the for loop.\n",
        "\n",
        "The following example outputs all elements in the cars array:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3RtCAVgWhI6w",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "ab8df575-a9a8-4493-9024-9bb0e8008121"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main() {\n",
        "    int i;\n",
        "    string ali[4] = {\"shahzad\",\"sohail\",\"hamza\",\"haya\"};\n",
        "    for( i = 0; i < 4; i++) {\n",
        "        cout << i << \":\" <<ali[i] << \"\\n\";\n",
        "    }\n",
        "    return 0;\n",
        "}"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "UsageError: Cell magic `%%cu` not found.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q_EnjMysmXtA"
      },
      "source": [
        "## **11.2-C++ Omit Array Size**\n",
        "\n",
        "You don't have to specify the size of the array. But if you don't, it will only be as big as the elements that are inserted into it:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dli714Hmm6I2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "e4bd9f46-e90a-4dba-89e6-a79bcd2cc042"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main() {\n",
        "    int i;\n",
        "    string ali[] = {\"hello\", \"world\",\"key\",\"school\"};\n",
        "    for(i =0; i < 4; i++) {\n",
        "        cout << i << \":\" <<ali[i] << \"\\n\";\n",
        "    }\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "UsageError: Cell magic `%%cu` not found.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fPxquldAstcO"
      },
      "source": [
        "#**12-C++ References**\n",
        "\n",
        " A reference variable is a \"reference\" to an existing variable, and it is created with the & operator:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lhANVR0-tZJJ",
        "outputId": "86d3daee-ec00-482b-82f8-77f4b3dfffb9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main() {\n",
        "    string ali = \"pizza\";\n",
        "    string &meal = ali;\n",
        "\n",
        "    cout << ali <<endl;\n",
        "    cout << meal <<endl;\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "UsageError: Cell magic `%%cu` not found.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bYVQO3MQ6Mko"
      },
      "source": [
        "#**13-C++ Memory Address**\n",
        "\n",
        "In the example from the previous page, the & operator was used to create a reference variable. But it can also be used to get the memory address of a variable; which is the location of where the variable is stored on the computer.\n",
        "\n",
        "When a variable is created in C++, a memory address is assigned to the variable. And when we assign a value to the variable, it is stored in this memory address.\n",
        "\n",
        "To access it, use the & operator, and the result will represent where the variable is stored:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UNIfawb86g7J"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int main() {\n",
        "    string food = \"pizza\";\n",
        "\n",
        "    cout <<&food;\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nUSGbwzilwYY"
      },
      "source": [
        "#**14-C++ Pointers**\n",
        "\n",
        "You learned from the previous chapter, that we can get the memory address of a variable by using the & operator:\n",
        "\n",
        "A pointer however, is a variable that stores the memory address as its value.\n",
        "\n",
        "\n",
        "A pointer variable points to a data type (like int or string) of the same type, and is created with the * operator. The address of the variable you're working with is assigned to the pointer:\n",
        "\n",
        "**Example explained**\n",
        "\n",
        "Create a pointer variable with the name ptr, that points to a string variable, by using the asterisk sign * (string* ptr). Note that the type of the pointer has to match the type of the variable you're working with.\n",
        "\n",
        "Use the & operator to store the memory address of the variable called food, and assign it to the pointer.\n",
        "\n",
        "Now, ptr holds the value of food's memory address."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OphkYtZz1bv7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "77cfde79-34df-45ff-e6fe-9f395355c3d2"
      },
      "source": [
        "%%writefile pointer.cpp\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        " int main(){\n",
        "     string food = \"pizza\";\n",
        "     string* ptr = &food;\n",
        "\n",
        "     cout << food <<endl;\n",
        "     cout << &food <<endl;\n",
        "     cout << ptr <<endl;\n",
        "     return 0;\n",
        "     }\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing pointer.cpp\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!nvcc /content/pointer.cpp -o output"
      ],
      "metadata": {
        "id": "l1v3QT9LZk3h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!./output"
      ],
      "metadata": {
        "id": "CU3pTp-iZqh5",
        "outputId": "8c374b59-a027-43f1-dc1d-4d599416baf3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "pizza\n",
            "0x7ffc89a98c60\n",
            "0x7ffc89a98c60\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "APmm_FM2pPO0"
      },
      "source": [
        "#**15-C++ Functions**\n",
        "\n",
        "A function is a block of code which only runs when it is called.\n",
        "\n",
        "You can pass data, known as parameters, into a function.\n",
        "\n",
        "Functions are used to perform certain actions, and they are important for reusing code: Define the code once, and use it many times.\n",
        "\n",
        "**Create a Function**\n",
        "\n",
        "C++ provides some pre-defined functions, such as main(), which is used to execute code. But you can also create your own functions to perform certain actions.\n",
        "\n",
        "To create (often referred to as declare) a function, specify the name of the function, followed by parentheses ():\n",
        "\n",
        "**Syntax**\n",
        "\n",
        "void myFunction() {\n",
        "  // code to be executed\n",
        "}\n",
        "\n",
        "**Example Explained**\n",
        "\n",
        "- myFunction() is the name of the function\n",
        "- void means that the function does not have a return  value. You will learn more about return values later in the next chapter\n",
        "- inside the function (the body), add code that defines what the function should do\n",
        "\n",
        "**Call a Function**\n",
        "\n",
        "Declared functions are not executed immediately. They are \"saved for later use\", and will be executed later, when they are called.\n",
        "\n",
        "To call a function, write the function's name followed by two parentheses () and a semicolon ;\n",
        "\n",
        "In the following example, myFunction() is used to print a text (the action), when it is called:\n",
        "\n",
        "**Example**\n",
        "\n",
        "Inside main, call myFunction():\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SPwGjHqPsxGt"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "void pakistan() {\n",
        "    cout << \"long live pakistan!\";\n",
        "}\n",
        "int main(){\n",
        "    cout <<\"first output\"<<endl;\n",
        "  pakistan();\n",
        "  cout <<\"second output\"<<endl;\n",
        "   pakistan();\n",
        "   return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LPAjC4CYKhIr"
      },
      "source": [],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "We-bD_i7JLuf"
      },
      "source": [
        "**Function Declaration and Definition**\n",
        "\n",
        "A C++ function consist of two parts:\n",
        "\n",
        "- Declaration: the function's name, return type, and parameters (if any)\n",
        "- Definition: the body of the function (code to be executed)\n",
        "\n",
        "Note: If a user-defined function, such as myFunction() is declared after the main() function, an error will occur. It is because C++ works from top to bottom; which means that if the function is not declared above main(), the program is unaware of it:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fCZKZPw4KjGZ"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "void myFunction() {\n",
        "  cout << \"I just got executed!\";\n",
        "}\n",
        "\n",
        "\n",
        "int main() {\n",
        "  myFunction();\n",
        "  return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bPCJYXj8FrTF"
      },
      "source": [
        "##**15.1-C++ Function Parameters**\n",
        "\n",
        "Information can be passed to functions as a parameter. Parameters act as variables inside the function.\n",
        "\n",
        "Parameters are specified after the function name, inside the parentheses. You can add as many parameters as you want, just separate them with a comma:\n",
        "\n",
        "When a parameter is passed to the function, it is called an argument. So, from the example above: fname is a parameter, while Liam, Jenny and Anja are arguments."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q6zcI0JRGTsb"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "void hussain(string word) {\n",
        "    cout << word <<endl;\n",
        "}\n",
        "    int main(){\n",
        "        hussain(\"school\");\n",
        "        hussain(\"book\");\n",
        "        hussain(\"pen\");\n",
        "        hussain(\"pencial\");\n",
        "        return 0;\n",
        "    }"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n5-qq5GCEhRu"
      },
      "source": [
        "##**15.2-C++ Default Parameters**\n",
        "\n",
        "You can also use a default parameter value, by using the equals sign (=).\n",
        "\n",
        "If we call the function without an argument, it uses the default value (\"Norway\"):\n",
        "\n",
        "A parameter with a default value, is often known as an \"optional parameter\". From the example above, country is an optional parameter and \"Norway\" is the default value."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R-QRTROFFF9u"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "void shahzad(string name =\"haider\"){\n",
        "cout << name <<endl;\n",
        "}\n",
        "int main(){\n",
        "shahzad(\"haya\");\n",
        "shahzad(\"summar\");\n",
        "shahzad();\n",
        "shahzad(\"ayan\");\n",
        "return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iBvuO9zTObed"
      },
      "source": [
        "##**15.3-C++ Multiple Parameters**\n",
        "\n",
        "Inside the function, you can add as many parameters as you want:\n",
        "\n",
        "Note that when you are working with multiple parameters, the function call must have the same number of arguments as there are parameters, and the arguments must be passed in the same order."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jA75IpobO1mk"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "void work(string shahzad, int age) {\n",
        "     cout << shahzad << \" endl. \" << age << \" years old.endl\";\n",
        "}\n",
        "int main(){\n",
        "    work(\"haya\",5);\n",
        "    work(\"summar\",11);\n",
        "    work(\"mahdi\",4);\n",
        "    work(\"lahar\",10);\n",
        "    return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GIJQufyY80xa"
      },
      "source": [
        "##**15.4-C++ The Return Keyword**\n",
        "\n",
        "The void keyword, used in the previous examples, indicates that the function should not return a value. If you want the function to return a value, you can use a data type (such as int, string, etc.) instead of void, and use the return keyword inside the function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NyToEurM9RtM",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "outputId": "883f91f2-2f59-4ceb-b11d-7bac873a9182"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int world(int x, int y) {\n",
        "    int sum = x+y;\n",
        "    return sum;\n",
        "}\n",
        "int main(){\n",
        "    int finalsum = world(5 , 7);\n",
        "    cout <<finalsum<<endl;\n",
        "    return 0;\n",
        "}"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "12\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PQY0B5E5B4Ip"
      },
      "source": [
        "##**15.5-C++ Function Overloading**\n",
        "\n",
        "With function overloading, multiple functions can have the same name with different parameters:\n",
        "\n",
        "Instead of defining two functions that should do the same thing, it is better to overload one.\n",
        "\n",
        "In the example below, we overload the plusFunc function to work for both int and double:\n",
        "\n",
        "Note: Multiple functions can have the same name as long as the number and/or type of parameters are different."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iKnJVdmxNGcC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        },
        "outputId": "87aadcf6-2cd0-4df0-e48e-fc8e2fbffefc"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "int myfunction(int x, int y) {\n",
        "    return  x + y;\n",
        "}\n",
        "double myfunction(double x, double y) {\n",
        "    return x + y;\n",
        "}\n",
        "int main(){\n",
        "    int number1 = myfunction(8 , 6);\n",
        "    double number2 = myfunction(5.5 , 2.5);\n",
        "    cout <<\"Int: \" << number1<<endl;\n",
        "    cout <<\"Double: \" <<number2<<endl;\n",
        "    return 0;\n",
        "}"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Int: 14\n",
            "Double: 8\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x2B9CUQsagFb"
      },
      "source": [
        "#**16-C++ OOP**\n",
        "\n",
        "**C++ What is OOP?**\n",
        "\n",
        "OOP stands for Object-Oriented Programming.\n",
        "\n",
        "Procedural programming is about writing procedures or functions that perform operations on the data, while object-oriented programming is about creating objects that contain both data and functions.\n",
        "\n",
        "Object-oriented programming has several advantages over procedural programming:\n",
        "\n",
        "- OOP is faster and easier to execute\n",
        "- OOP provides a clear structure for the programs\n",
        "- OOP helps to keep the C++ code DRY \"Don't Repeat Yourself\", and makes the code easier to maintain, modify and debug\n",
        "- OOP makes it possible to create full reusable applications with less code and shorter development time.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UFiLQeS-bXWQ"
      },
      "source": [
        "##**16.1-C++ What are Classes and Objects?**\n",
        "\n",
        "Classes and objects are the two main aspects of object-oriented programming.\n",
        "\n",
        "Look at the following illustration to see the difference between class and objects:\n",
        "\n",
        "So, a class is a template for objects, and an object is an instance of a class.\n",
        "\n",
        "When the individual objects are created, they inherit all the variables and functions from the class.\n",
        "\n",
        "You will learn much more about classes and objects in the next chapter."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6avXp3e6i0gy"
      },
      "source": [
        "![](https://drive.google.com/uc?export=view&id=1OiI0OM8SZDffAmtpczf56BYziR6f_b2T)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0-yalxwvbwV_"
      },
      "source": [
        "##**16.2-C++ Classes and Objects**\n",
        "\n",
        " C++ is an object-oriented programming language.\n",
        "\n",
        "Everything in C++ is associated with classes and objects, along with its attributes and methods. For example: in real life, a car is an object. The car has attributes, such as weight and color, and methods, such as drive and brake.\n",
        "\n",
        "Attributes and methods are basically variables and functions that belongs to the class. These are often referred to as \"class members\".\n",
        "\n",
        "A class is a user-defined data type that we can use in our program, and it works as an object constructor, or a \"blueprint\" for creating objects.\n",
        "\n",
        "**Create a Class**\n",
        "To create a class, use the class keyword:\n",
        "Create a class called \"MyClass\":\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fkzkxwUccMSv"
      },
      "source": [
        "class MyClass {       // The class\n",
        "  public:             // Access specifier\n",
        "    int myNum;        // Attribute (int variable)\n",
        "    string myString;  // Attribute (string variable)\n",
        "};"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ikW440GpcXle"
      },
      "source": [
        "**Example explained**\n",
        "- The class keyword is used to create a class called MyClass.\n",
        "- The public keyword is an access specifier, which specifies that members (attributes and methods) of the class are accessible from outside the class. You will learn more about access specifiers later.\n",
        "\n",
        "- Inside the class, there is an integer variable myNum and a string variable myString. When variables are declared within a class, they are called attributes.\n",
        "\n",
        "- At last, end the class definition with a semicolon ;."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iFNDPAfEc6Vr"
      },
      "source": [
        "##**16.3-Create an Object**\n",
        "\n",
        "In C++, an object is created from a class. We have already created the class named MyClass, so now we can use this to create objects.\n",
        "\n",
        "To create an object of MyClass, specify the class name, followed by the object name.\n",
        "\n",
        "To access the class attributes (myNum and myString), use the dot syntax (.) on the object:\n",
        "\n",
        "**Example**\n",
        "Create an object called \"myObj\" and access the attributes:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "knHNJ5ixd38f"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "class MyClass {       //  class\n",
        "  public:             //  specifier\n",
        "    int myNum;        // Attribute (int )\n",
        "    string myString;  // Attribute (string)\n",
        "};\n",
        "\n",
        "int main() {\n",
        "  MyClass myObj;  //  object of MyClass\n",
        "\n",
        "  // Access attributes and set values\n",
        "  myObj.myNum = 70;\n",
        "  myObj.myString = \"pakistan\";\n",
        "\n",
        "  // Print values\n",
        "  cout << myObj.myNum <<endl;\n",
        "  cout << myObj.myString <<endl;\n",
        "  return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yw4fArnyUtQs"
      },
      "source": [
        "##**16.4-Multiple Objects**\n",
        "You can create multiple objects of one class:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n5I0jPviVQV_"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "class car {\n",
        "    public:\n",
        "    string brand;\n",
        "    string model;\n",
        "    int year;\n",
        "};\n",
        "\n",
        "int main(){\n",
        "    car carobj1;\n",
        "    carobj1.brand = \"BMW\";\n",
        "    carobj1.model = \"vvt\";\n",
        "    carobj1.year = 2002;\n",
        "\n",
        "    car carobj2;\n",
        "    carobj2.brand = \"toyota\";\n",
        "    carobj2.model = \"vvtr\";\n",
        "    carobj2.year = 2006;\n",
        "\n",
        "    cout << carobj1.brand << \" \" << carobj1.model << \" \" << carobj1.year <<endl;\n",
        "    cout << carobj2.brand << \" \" <<carobj2.model << \" \" << carobj2.year <<endl;\n",
        "    return 0;\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YKs9jqr5ypCy"
      },
      "source": [
        "##**16.5-C++ Class Methods**\n",
        "Methods are functions that belongs to the class.\n",
        "\n",
        "There are two ways to define functions that belongs to a class:\n",
        "\n",
        "- Inside class definition\n",
        "- Outside class definition\n",
        "\n",
        "In the following example, we define a function inside the class, and we name it \"myMethod\".\n",
        "\n",
        "**Note**: You access methods just like you access attributes; by creating an object of the class and by using the dot syntax (.):"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8tNhfq4re__H"
      },
      "source": [
        "**inside**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sm1ZZJQ9roBY",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "f230050b-58be-4e4a-8dac-36ac88010d4f"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "class pakistan {\n",
        "    public:\n",
        "    void mymethod() {\n",
        "        cout <<\"pakistani people\";\n",
        "    }\n",
        "    };\n",
        "    int main() {\n",
        "        pakistan myobj;\n",
        "        myobj.mymethod();\n",
        "        return 0;\n",
        "    }\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "pakistani people\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "30mXZ2RhfOZq"
      },
      "source": [
        "**0utside example**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8ypQq7r9gS4b"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "class myclass {\n",
        "    public:\n",
        "    void mymethod();\n",
        "};\n",
        "void myclass::mymethod(){\n",
        "    cout << \"pakistan\";\n",
        "}\n",
        " int main(){\n",
        "     myclass myobj;\n",
        "     myobj.mymethod();\n",
        "     return 0;\n",
        " }"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TjfHMajLi1Dm"
      },
      "source": [
        "#**17-C++ Constructors**\n",
        "\n",
        "A constructor in C++ is a special method that is automatically called when an object of a class is created.\n",
        "\n",
        "To create a constructor, use the same name as the class, followed by parentheses ():"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3AvaEXu2-QxC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "0f95d523-49db-4d10-ce74-0d3caf355cd5"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "class shahzad {     // class\n",
        "  public:           //  specifier\n",
        "    shahzad() {     // Constructor\n",
        "      cout << \"Hello World!\";\n",
        "    }\n",
        "};\n",
        "\n",
        "int main() {\n",
        "  shahzad myObj;    // this will call the constructor\n",
        "  return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "UsageError: Cell magic `%%cu` not found.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_F28EhuSu1eD"
      },
      "source": [
        "#**17.1-Constructor Parameters**\n",
        "\n",
        "Constructors can also take parameters (just like regular functions), which can be useful for setting initial values for attributes.\n",
        "\n",
        "The following class have brand, model and year attributes, and a constructor with different parameters. Inside the constructor we set the attributes equal to the constructor parameters (brand=x, etc). When we call the constructor (by creating an object of the class), we pass parameters to the constructor, which will set the value of the corresponding attributes to the same:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xn431nakKXzT"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "class Car {        //  class\n",
        "  public:          //  specifier\n",
        "    string brand;  // Attribute\n",
        "    string model;  // Attribute\n",
        "    int year;      // Attribute\n",
        "    Car(string x, string y, int z) {  // Constructor with parameters\n",
        "      brand = x;\n",
        "      model = y;\n",
        "      year = z;\n",
        "    }\n",
        "};\n",
        "\n",
        "int main() {\n",
        "  // Create Car objects and call the constructor with different values\n",
        "  Car carObj1(\"toyota\", \"vvt\", 2006);\n",
        "  Car carObj2(\"honda\", \"vvtr\", 2012);\n",
        "\n",
        "  // Print values\n",
        "  cout << carObj1.brand << \" \" << carObj1.model << \" \" << carObj1.year << endl;\n",
        "  cout << carObj2.brand << \" \" << carObj2.model << \" \" << carObj2.year << endl;\n",
        "  return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aNN7SeiV-53A"
      },
      "source": [
        "#**18-C++ Access Specifiers**\n",
        "By now, you are quite familiar with the public keyword that appears in all of our class examples:\n",
        "\n",
        "The public keyword is an access specifier. Access specifiers define how the members (attributes and methods) of a class can be accessed. In the example above, the members are public - which means that they can be accessed and modified from outside the code.\n",
        "\n",
        "However, what if we want members to be private and hidden from the outside world?\n",
        "\n",
        "In C++, there are three access specifiers:\n",
        "\n",
        "- public - members are accessible from outside the class\n",
        "- private - members cannot be accessed (or viewed) from outside the class\n",
        "- protected - members cannot be accessed from outside the class, however, they can be accessed in inherited classes. You will learn more about Inheritance later.\n",
        "\n",
        "In the following example, we demonstrate the differences between public and private members:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q1lHdkf0_8pS",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "f4166a20-ea26-4a8b-8800-95eb999da2d8"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "class myclass{     // class\n",
        "    public:        // public acccess specifier\n",
        "    int x;         // attributes\n",
        "    private:      // private access specifier\n",
        "    int y;         // attributes\n",
        "\n",
        "};\n",
        "\n",
        "int main() {\n",
        "  myclass myObj;\n",
        "  myObj.x = 90;\n",
        "  //myObj.y = 60;\n",
        "  return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wrzNmUoEKkc0"
      },
      "source": [
        "#**18-C++ Encapsulation**\n",
        "\n",
        " The meaning of Encapsulation, is to make sure that \"sensitive\" data is hidden from users. To achieve this, you must declare class variables/attributes as private (cannot be accessed from outside the class). If you want others to read or modify the value of a private member, you can provide public get and set methods.\n",
        "\n",
        " **Access Private Members**\n",
        "\n",
        "\n",
        "To access a private attribute, use public \"get\" and \"set\" methods:\n",
        "\n",
        "**Example explained**\n",
        "The salary attribute is private, which have restricted access.\n",
        "\n",
        "The public setSalary() method takes a parameter (s) and assigns it to the salary attribute (salary = s).\n",
        "\n",
        "The public getSalary() method returns the value of the private salary attribute.\n",
        "\n",
        "Inside main(), we create an object of the Employee class. Now we can use the setSalary() method to set the value of the private attribute to 50000. Then we call the getSalary() method on the object to return the value."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LZUtxrMBLG0Q"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "class Employee {\n",
        "  private:\n",
        "    int salary;\n",
        "\n",
        "  public:\n",
        "    void setSalary(int s) {\n",
        "      salary = s;\n",
        "    }\n",
        "    int getSalary() {\n",
        "      return salary;\n",
        "    }\n",
        "};\n",
        "\n",
        "int main() {\n",
        "  Employee myObj;\n",
        "  myObj.setSalary(20000);\n",
        "  cout << myObj.getSalary();\n",
        "  return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p_UUoBOcIPgl"
      },
      "source": [
        "#**19-C++ Inheritance**\n",
        "\n",
        "In C++, it is possible to inherit attributes and methods from one class to another. We group the \"inheritance concept\" into two categories:\n",
        "\n",
        "- derived class (child) - the class that inherits from another class\n",
        "- base class (parent) - the class being inherited from\n",
        "To inherit from a class, use the : symbol.\n",
        "\n",
        "In the example below, the Car class (child) inherits the attributes and methods from the Vehicle class (parent):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f9VJ1RBkIiaR"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "// Base class\n",
        "class Vehicle {\n",
        "  public:\n",
        "    string brand = \"toyota\";\n",
        "    void honk() {\n",
        "      cout << \"Tuut, tuut\"<<endl;\n",
        "    }\n",
        "};\n",
        "\n",
        "// Derived class\n",
        "class Car: public Vehicle {\n",
        "  public:\n",
        "    string model = \"Mustang\";\n",
        "};\n",
        "\n",
        "int main() {\n",
        "  Car myCar;\n",
        "  myCar.honk();\n",
        "  cout << myCar.brand + \" \" + myCar.model;\n",
        "  return 0;\n",
        "}\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5la1foDEJBf1"
      },
      "source": [
        "##**19.1-C++ Multilevel Inheritance**\n",
        "\n",
        " class can also be derived from one class, which is already derived from another class.\n",
        "\n",
        "In the following example, MyGrandChild is derived from class MyChild (which is derived from MyClass)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dgrXvg5aJXZM"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "// Parent class\n",
        "class MyClass {\n",
        "  public:\n",
        "    void myFunction() {\n",
        "      cout << \"Some content in parent class.\" ;\n",
        "    }\n",
        "};\n",
        "\n",
        "// Child class\n",
        "class MyChild: public MyClass {\n",
        "};\n",
        "\n",
        "// Grandchild class\n",
        "class MyGrandChild: public MyChild {\n",
        "};\n",
        "\n",
        "int main() {\n",
        "  MyGrandChild myObj;\n",
        "  myObj.myFunction();\n",
        "  return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-K-eaTkjYOs7"
      },
      "source": [
        "##**19.2-Multiple Inheritance**\n",
        "\n",
        "A class can also be derived from more than one base class, using a comma-separated list:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B5M8sy3SYm9g"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "class myclass {\n",
        "    public:\n",
        "    void myfunction() {\n",
        "        cout <<\"shahzad hussain\"<<endl;\n",
        "    }\n",
        "};\n",
        "class myotherclass {\n",
        "    public:\n",
        "    void myotherfunction(){\n",
        "        cout <<\"pakistan\"<<endl;\n",
        "    }\n",
        "};\n",
        "class mychildclass:public myclass,public myotherclass{\n",
        "\n",
        "};\n",
        "int main() {\n",
        "    mychildclass myobj;\n",
        "    myobj.myfunction();\n",
        "    myobj.myotherfunction();\n",
        "    return 0;\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iknD_cDNhdry"
      },
      "source": [
        "#**19.3-Access Specifiers**\n",
        "\n",
        "You learned from the Access Specifiers chapter that there are three specifiers available in C++. Until now, we have only used public (members of a class are accessible from outside the class) and private (members can only be accessed within the class). The third specifier, protected, is similar to private, but it can also be accessed in the inherited class:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6TdQDC7GEN2_"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "// Base class\n",
        "class Employee  {\n",
        "  protected:  // Protected access specifier\n",
        "    int salary;\n",
        "};\n",
        "\n",
        "// Derived class\n",
        "class Programmer: public Employee {\n",
        "  public:\n",
        "    int bonus;\n",
        "    void setSalary(int s) {\n",
        "      salary = s;\n",
        "    }\n",
        "    int getSalary() {\n",
        "      return salary;\n",
        "    }\n",
        "};\n",
        "\n",
        "int main() {\n",
        "  Programmer myObj;\n",
        "  myObj.setSalary(70000);\n",
        "  myObj.bonus = 1500;\n",
        "  cout << \"Salary: \" << myObj.getSalary() << \"\\n\";\n",
        "  cout << \"Bonus: \" << myObj.bonus << \"\\n\";\n",
        "  return 0;\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IJgVGG4OglE2"
      },
      "source": [
        "#**20-Polymorphism**\n",
        "\n",
        "Polymorphism means \"many forms\", and it occurs when we have many classes that are related to each other by inheritance.\n",
        "\n",
        "Like we specified in the previous chapter; Inheritance lets us inherit attributes and methods from another class. Polymorphism uses those methods to perform different tasks. This allows us to perform a single action in different ways.\n",
        "\n",
        "For example, think of a base class called Animal that has a method called animalSound(). Derived classes of Animals could be Pigs, Cats, Dogs, Birds - And they also have their own implementation of an animal sound (the pig oinks, and the cat meows, etc.):\n",
        "\n",
        "Remember from the Inheritance chapter that we use the : symbol to inherit from a class.\n",
        "\n",
        "Now we can create Pig and Dog objects and override the animalSound() method:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PqCHO3i1hHiT"
      },
      "source": [
        "%%cu\n",
        "#include <iostream>\n",
        "using namespace std;\n",
        "\n",
        "class animal{\n",
        "    public:\n",
        "    void animalsound(){\n",
        "        cout <<\"animal make a sound\"<<endl;\n",
        "    }\n",
        "};\n",
        "class pig:public animal{\n",
        "    public:\n",
        "    void animalsound(){\n",
        "        cout <<\"sound of wildforest\"<<endl;\n",
        "    }\n",
        "};\n",
        "class dog: public animal{\n",
        "    public:\n",
        "    void animalsound(){\n",
        "        cout <<\"sound of gangal\"<<endl;\n",
        "    }\n",
        "};\n",
        "\n",
        "int main(){\n",
        "    animal myanimal;\n",
        "    pig mypig;\n",
        "    dog mydog;\n",
        "\n",
        "    myanimal.animalsound();\n",
        "    mypig.animalsound();\n",
        "    mydog.animalsound();\n",
        "    return 0;\n",
        "\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JrbtBoIiWTUX"
      },
      "source": [
        "#**Reference**\n",
        "C++ Tutorial\n",
        "https://www.w3schools.com/cpp/cpp_strings.asp\n",
        "\n",
        "https://www.learn-cpp.org/en/Variables_and_Types\n",
        "\n",
        "How to Run CUDA C or C++ on Jupyter (Google Colab)\n",
        "\n",
        "https://www.wikihow.com/Run-CUDA-C-or-C%2B%2B-on-Jupyter-(Google-Colab)\n",
        "\n",
        "Code block\n",
        "http://www.codeblocks.org/downloads/26\n",
        "\n",
        "Freebootcamp\n",
        "https://www.freecodecamp.org/\n",
        "\n",
        "ntroduction to C++ Programming in Urdu\n",
        "https://www.youtube.com/watch?v=dnCO124Uk1o\n",
        "\n",
        "6 Sentiment Analysis Projects with Python\n",
        "\n",
        "https://amankharwal.medium.com/6-sentiment-analysis-projects-with-python-1fdd3d43d90f"
      ]
    }
  ]
}