XQA
Back to C++
2025-12-226 min read

JS Array const (C++)

Learn JS Array const (C++) step by step with clear examples and exercises.

Why This Matters

The const keyword is a crucial concept in C++ programming that enables developers to declare immutable variables, ensuring code reliability and readability. When working with Emscripten, the ability to use C++'s const keyword becomes even more valuable as it can help port high-performance C++ libraries to the web without sacrificing performance or introducing unnecessary errors.

By using const variables, you can improve your code's maintainability and reduce the likelihood of runtime errors. In addition, constant values are often optimized by compilers, leading to better performance in some cases.

Prerequisites

To fully understand this lesson, you should have a solid grasp of:

  1. The basics of C++ syntax and concepts, including variables, functions, and control structures.
  2. JavaScript syntax and concepts, such as variables, functions, and object manipulation.
  3. Emscripten toolchain fundamentals, including how to compile C/C++ code for the web using asm.js and WebAssembly.
  4. Familiarity with a text editor or Integrated Development Environment (IDE) for writing and compiling C++ code.
  5. Basic understanding of command-line interfaces and navigation within your operating system.
  6. Understanding of Emscripten's APIs, such as emcc and emmake, to compile and link C++ projects with JavaScript.
  7. Knowledge of how to create simple HTML files for testing compiled JavaScript output in a web browser.

Core Concept

In C++, the const keyword is used to declare variables that cannot be modified once they have been assigned a value. When using Emscripten, the const keyword behaves similarly in JavaScript, ensuring constant values are preserved throughout the code execution.

#include <iostream>

int main() {
const int MY_CONSTANT = 42;
std::cout << "The value of MY_CONSTANT is: " << MY_CONSTANT << std::endl;
return 0;
}

When compiled with Emscripten, the output JavaScript will contain a constant variable MY_CONSTANT that cannot be modified.

(function () {
"use strict";

const MY_CONSTANT = 42;

function main() {
console.log("The value of MY_CONSTANT is: " + MY_CONSTANT);
}

return { main_module: { initializers: [main] } };
})();

In the JavaScript output, you can see that MY_CONSTANT is declared as a constant using the const keyword. This constant variable behaves similarly to its counterpart in C++ and cannot be modified after it has been initialized.

Constants and Initialization

Note that that when initializing a constant variable, you must provide an explicit value at the time of declaration. Attempting to assign a value later will result in a compilation error.

int MY_CONSTANT; // Compilation Error: undefined variable 'MY_CONSTANT'
const int MY_CONSTANT = 42; // Correct initialization

Constants and Expressions

In C++, you can use expressions to initialize constant variables. The result of the expression must be a compile-time constant.

const int SQUARE = 2 * 2; // Compile-time constant expression
const int PI = 3.14159265358979323846; // Constant floating-point value

Worked Example

Let's create a simple C++ program that uses const variables to calculate the area of a rectangle, given the length and width as command-line arguments. We will then compile the code with Emscripten, create a simple HTML file, and test the compiled JavaScript output in a web browser.

  1. Create a new file called main.cpp and add the following code:
#include <iostream>
#include <cmath>

int main(int argc, char* argv[]) {
if (argc != 3) {
std::cerr << "Usage: ./program length width" << std::endl;
return 1;
}

const int length = std::stoi(argv[1]);
const int width = std::stoi(argv[2]);

const int area = length * width;

std::cout << "The area of the rectangle is: " << area << std::endl;
return 0;
}
  1. Install Emscripten by following the instructions in the Emscripten GitHub repository.
  1. Create a new directory for your project and navigate to it in the terminal.
  1. Initialize the Emscripten SDK by running:
emcmake cmake -DCMAKE_BUILD_TYPE=Release -DENABLE_GLFW=0 .
  1. Compile the C++ code to JavaScript using:
emcc main.cpp -O3 -s ALLOW_MEMORY_GROWTH=1 -o main.js
  1. Open index.html in a text editor and add the following code:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>C++ const with Emscripten</title>
</head>
<body>
<h1>C++ const with Emscripten</h1>
<p>Enter the length and width of a rectangle:</p>
<input type="number" id="length" placeholder="Length">
<input type="number" id="width" placeholder="Width">
<button onclick="calculateArea()">Calculate Area</button>
<p id="result"></p>

<script src="main.js"></script>
<script>
function calculateArea() {
const length = document.getElementById('length').value;
const width = document.getElementById('width').value;

postMessage(JSON.stringify({"length": length, "width": width}));
}

onmessage = function (event) {
const data = JSON.parse(event.data);
const area = computeArea(data.length, data.width);
postMessage(JSON.stringify({"area": area}));
};

function computeArea(length, width) {
return length * width;
}
</script>
</body>
</html>
  1. Save the file and open it in a web browser. Enter the length and width of a rectangle, click "Calculate Area," and observe the output.

Common Mistakes

  1. Modifying a constant variable: Trying to modify a constant variable after it has been assigned a value will result in a compilation error or runtime error, depending on the context.
  1. Using const with non-primitive types: In C++, you cannot declare objects or arrays as const. When using Emscripten, this restriction also applies to JavaScript objects and arrays.
  1. Incorrectly declaring constant pointers: If you want to create a pointer that points to a constant value, use the const keyword after the pointer type, not before it. For example:
const int* const myPointer = &MY_CONSTANT; // Correct declaration
int const* myPointer = &MY_CONSTANT; // Incorrect declaration (use const int* const instead)
  1. Forgetting to handle incorrect command-line argument counts: When using command-line arguments, forgetting to check the number of arguments can lead to unexpected behavior or errors.
  1. Using non-constant expressions for constant initialization: Attempting to use non-constant expressions (e.g., function calls) for initializing a constant variable will result in a compilation error.

Practice Questions

  1. Write a C++ program that uses const variables to calculate the area of a circle, given the radius as a command-line argument. Compile the code with Emscripten and create a simple HTML file to test the compiled JavaScript output in a web browser.
  1. Modify the example provided earlier (main.cpp, index.html) to include error handling for incorrect command-line argument counts when using the program.
  1. Create an Emscripten project that uses a constant pointer to access elements of a constant array, and test it in a web browser.
  1. Write a C++ function that takes two const integer arguments and returns their sum as a const int. Compile the code with Emscripten and create a simple HTML file to test the compiled JavaScript output in a web browser.

FAQ

  1. Can I use C++ const with Emscripten to create constant functions?

Yes, you can declare functions as constexpr in C++, which will be treated as constants at compile time if their values do not depend on run-time variables. When using Emscripten, these functions will behave similarly in JavaScript.

  1. Is it possible to create constant arrays or objects with const in C++ and Emscripten?

No, you cannot declare constant arrays or objects in C++ due to the nature of their mutable elements. However, you can use const to declare pointers to constant arrays or objects.

  1. What happens if I try to modify a constant variable in my JavaScript code after compiling with Emscripten?

If you attempt to modify a constant variable in your compiled JavaScript output, the resulting behavior will depend on the context. In some cases, it may result in an error, while in others it might silently update the value without raising any errors. It's essential to ensure that you do not try to modify constant variables after they have been initialized.

  1. How can I handle command-line arguments with Emscripten when using const variables?

To handle command-line arguments with Emscripten and const variables, you should check the number of arguments passed to your program and validate their types before using them in your calculations. This helps prevent unexpected behavior or errors due to incorrect input.

  1. How can I use constexpr functions with Emscripten?

To use constexpr functions with Emscripten, you should ensure that the function's return type is a compile-time constant and does not depend on run-time variables. When compiling your C++ code with Emscripten, make sure to include the -std=c++11 flag to enable support for C++11 features like constexpr.

JS Array const (C++) | C++ | XQA Learn