C++ Pointers are variables that hold the address of other variables. They facilitate direct access to memory and enable dynamic memory management. Pointers are extensively utilized in numerous real-world scenarios, including game development. In this article, we will explore what a pointer is, how to create, declare, and initialize a pointer, how to dereference a pointer, the various pointer types, their applications, smart pointers, and optimal practices for using pointers in C++.
Pointers are variables designed to preserve the memory address of other variables. A pointer does not contain the actual value of a variable; instead, it retains the location in memory where that value resides. They can be utilized with all data types, be it basic types like integers and characters or user-defined types like classes and structures.
Creating a Pointer in C++
A pointer can be established by declaring it with a specific data type and initializing it with a variable’s address.
Syntax:
type* pointerName = &variableName;
type – This denotes the data type of the variable the pointer will refer to.
*pointerName – This is the name of the pointer variable, including the asterisk which indicates that it is a pointer.
&variableName – This is the address-of operator used to capture the memory address of the variable.
Pointer Declaration and Initialization in C++
A pointer in C++ is declared by specifying the data type of the variable to which it points, followed by an asterisk *, along with the pointer’s name. It is initialized by assigning it to the address of a variable using the & (address-of operator).
Declaration Syntax:
dataType* pointerName;
Initialization Syntax:
pointerName = &variableName;
Example:
Cpp
Code Copied!
var isMobile = window.innerWidth “);
editor48317.setValue(decodedContent); // Set the default text
editor48317.clearSelection();
editor48317.setOptions({
maxLines: Infinity
});
function decodeHTML48317(input) {
var doc = new DOMParser().parseFromString(input, “text/html”);
return doc.documentElement.textContent;
}
// Function to copy code to clipboard
function copyCodeToClipboard48317() {
const code = editor48317.getValue(); // Get code from the editor
navigator.clipboard.writeText(code).then(() => {
// alert(“Code copied to clipboard!”);
data: {
language: “cpp”,
code: code,
cmd_line_args: “”,
variablenames: “”,
action:”compilerajax”
},
success: function(response) {
var myArray = response.split(“~”);
var data = myArray[1];
jQuery(“.output48317”).html(“
"+data+"");
jQuery(".maineditor48317 .code-editor-output").show();
jQuery("#runBtn48317 i.run-code").hide();
}
})
}
function closeoutput48317() {
var code = editor48317.getSession().getValue();
jQuery(".maineditor48317 .code-editor-output").hide();
}
// Add event listeners to the buttons
document.getElementById("copyBtn48317").addEventListener("click", copyCodeToClipboard48317);
document.getElementById("runBtn48317").addEventListener("click", runCode48317);
document.getElementById("closeoutputBtn48317").addEventListener("click", closeoutput48317);
Result:
The snippet demonstrates how to declare and initialize a pointer in C++, which retains the address of the variable age in ptr, and subsequently, *ptr is utilized to access the value of age via the pointer.
Assigning an Address to a Pointer in C++
A pointer can receive an address using the address-of operator (&) applied to a variable.
Format:
int x = 10; int* p; // pointer declaration p = &x; // assigning the address of x to pointer p
Illustration:
Cpp
Code Copied!
var isMobile = window.innerWidth ");
editor23500.setValue(decodedContent); // Set the default text
editor23500.clearSelection();
editor23500.setOptions({
maxLines: Infinity
});
function decodeHTML23500(input) {
var doc = new DOMParser().parseFromString(input, "text/html");
return doc.documentElement.textContent;
}
// Function to copy code to clipboard
function copyCodeToClipboard23500() {
const code = editor23500.getValue(); // Retrieve code from the editor
navigator.clipboard.writeText(code).then(() => {
// alert("Code copied to clipboard!");
data: {
language: "cpp",
code: code,
cmd_line_args: "",
variablenames: "",
action:"compilerajax"
},
success: function(response) {
var myArray = response.split("~");
var data = myArray[1];
jQuery(".output23500").html("
"+data+"");
jQuery(".maineditor23500 .code-editor-output").show();
jQuery("#runBtn23500 i.run-code").hide();
}
})
}
function closeoutput23500() {
var code = editor23500.getSession().getValue();
jQuery(".maineditor23500 .code-editor-output").hide();
}
// Add event listeners to the buttons
document.getElementById("copyBtn23500").addEventListener("click", copyCodeToClipboard23500);
document.getElementById("runBtn23500").addEventListener("click", runCode23500);
document.getElementById("closeoutputBtn23500").addEventListener("click", closeoutput23500);
Result:
The snippet illustrates how the address of the variable number is allocated to the pointer ptr, allowing *ptr to retrieve its value. The pointer is also utilized to display the variable's address.
Dereferencing a Pointer in C++
Dereferencing a pointer involves accessing the value stored at the memory location of the variable to which the pointer refers by employing the * operator in C++.
Format: int* ptr = &x; int value = *ptr; // dereferencing to obtain the value of x
function closeoutput13072() {
jQuery(".maineditor13072 .code-editor-output").hide();
}
// Attach event listeners to the buttons
document.getElementById("copyBtn13072").addEventListener("click", copyCodeToClipboard13072);
document.getElementById("runBtn13072").addEventListener("click", runCode13072);
document.getElementById("closeoutputBtn13072").addEventListener("click", closeoutput13072);
Outcome:
This code illustrates how to retrieve the value of a variable from its memory address using *. Here, *ptr retrieves the value of the variable designated by ptr.
Adjusting Address in C++ (Pointer Reassignment)
A pointer can be reassigned to reference the address of another variable of the same type. This reassignment enables the pointer to point to different data throughout the execution of a C++ program.
"+data+"");
jQuery(".maineditor4290 .code-editor-output").show();
jQuery("#runBtn4290 i.run-code").hide();
}
})
}
function closeoutput4290() {
var code = editor4290.getSession().getValue();
jQuery(".maineditor4290 .code-editor-output").hide();
}
// Assign event handlers to the buttons
document.getElementById("copyBtn4290").addEventListener("click", copyCodeToClipboard4290);
document.getElementById("runBtn4290").addEventListener("click", runCode4290);
document.getElementById("closeoutputBtn4290").addEventListener("click", closeoutput4290);
Result:
This code illustrates how pointer reassignment enables the ptr to reference a, then ptr is modified to reference b, so *ptr will yield the value of b as output.
Pointer Sizes in C++
The size of a pointer in C++ is contingent upon the CPU architecture and operating system of the machine, rather than the type of variable it refers to. Hence, the size of a pointer remains uniform across all pointers in a given system.
In a 32-bit architecture, all pointers are 4 bytes.
In a 64-bit architecture, all pointers are 8 bytes.
Sample:
Cpp
Code Copied!
Result:
This code demonstrates how the size of the pointer is influenced by the system architecture, as the sizes of int, double, and char are 8 bytes, since the architecture is 64-bit.
Distinct Pointer Types in C++
In C++, there are five unique types of pointers that serve specific functions.
1. NULL Pointer
A NULL pointer is a pointer that does not reference any memory address and signifies that the pointer has intentionally not been assigned to any variable.
Syntax:
Below are both the contemporary and traditional forms.
int* ptr = nullptr; // C++11 and beyond
int* ptr = NULL; // Traditional C-style
Sample:
Cpp
Code Copied!
var isMobile = window.innerWidth ");
editor77434.setValue(decodedContent); // Set the initial text
editor77434.clearSelection();
editor77434.setOptions({
maxLines: Infinity
});
function decodeHTML77434(input) {
var doc = new DOMParser().parseFromString(input, "text/html");
return doc.documentElement.textContent;
}
// Function to copy code to clipboard
function copyCodeToClipboard77434() {
const code = editor77434.getValue(); // Retrieve code from the editor
navigator.clipboard.writeText(code).then(() => {
jQuery(".maineditor77434 .copymessage").show();
setTimeout(function() {
jQuery(".maineditor77434 .copymessage").hide();
}, 2000);
}).catch(err => {
console.error("Error copying code: ", err);
});
}
function runCode77434() {
var code = editor77434.getSession().getValue();
"+data+"");
jQuery(".maineditor44840 .code-editor-output").show();
jQuery("#runBtn44840 i.run-code").hide();
}
})
}
function closeoutput44840() {
var code = editor44840.getSession().getValue();
jQuery(".maineditor44840 .code-editor-output").hide();
}
// Bind event listeners to the buttons
document.getElementById("copyBtn44840").addEventListener("click", copyCodeToClipboard44840);
document.getElementById("runBtn44840").addEventListener("click", runCode44840);
document.getElementById("closeoutputBtn44840").addEventListener("click", closeoutput44840);
Output:
The example illustrates how a void* pointer is utilized to retain the address of an integer x, subsequently typecasting it to int* prior to dereferencing to retrieve the value, which is then displayed as output.
3. Wild Pointer
A wild pointer refers to a pointer that has been declared but remains uninitialized, pointing to an arbitrary memory address, potentially resulting in undefined behavior if accessed.
data: {
language: "cpp",
code: code,
cmd_line_args: "",
variablenames: "",
action:"compilerajax"
},
success: function(response) {
var myArray = response.split("~");
var data = myArray[1];
jQuery(".output42415").html("
"+data+"");
jQuery(".maineditor42415 .code-editor-output").show();
jQuery("#runBtn42415 i.run-code").hide();
}
})
}
function closeoutput42415() {
var code = editor42415.getSession().getValue();
jQuery(".maineditor42415 .code-editor-output").hide();
}
// Bind event listeners to the buttons
document.getElementById("copyBtn42415").addEventListener("click", copyCodeToClipboard42415);
document.getElementById("runBtn42415").addEventListener("click", runCode42415);
document.getElementById("closeoutputBtn42415").addEventListener("click", closeoutput42415);
Output:
This code demonstrates how a segmentation fault arises because ptr is a wild pointer; it remains uninitialized and points to an invalid memory area upon dereferencing.
4. Dangling Pointer
A dangling pointer occurs when a pointer still references memory that has been released or is out of scope, accessing such memory can result in undefined behavior.
Example:
Cpp
Code Copied!
Output:
The code demonstrates how the address of a variable x, which exits scope following the termination of the function, is returned, turning ptr into a dangling pointer and leading to unpredictable behavior when dereferenced.
5. Constant Pointers
In C++, a constant pointer can be declared in two primary manners, with certain limitations.
a) Pointer to Constant (const int* ptr)
You can modify the address that the pointer holds.
You cannot alter the value that the pointer references.
Example:
int x = 10, y = 20; const int* ptr = &x; // can't change *ptr ptr = &y; // permitted //*ptr = 30; // issue!
b) Constant Pointer (int* const ptr)
You cannot alter the address that the pointer holds.
You can change the value that the pointer points to.
data: {
language: "cpp",
code: code,
cmd_line_args: "",
variablenames: "",
action:"compilerajax"
},
success: function(response) {
var myArray = response.split("~");
var data = myArray[1];
jQuery(".output86989").html("
"+data+"");
jQuery(".maineditor86989 .code-editor-output").show();
jQuery("#runBtn86989 i.run-code").hide();
}
})
}
function closeoutput86989() {
var code = editor86989.getSession().getValue();
jQuery(".maineditor86989 .code-editor-output").hide();
}
// Attach event listeners to the buttons
document.getElementById("copyBtn86989").addEventListener("click", copyCodeToClipboard86989);
document.getElementById("runBtn86989").addEventListener("click", runCode86989);
document.getElementById("closeoutputBtn86989").addEventListener("click", closeoutput86989);
Output:
The code demonstrates how the name of an array serves as a pointer to its initial element, enabling element access through pointer arithmetic *(arr + i) as opposed to arr[i].
Presented below is a comparison table illustrating the differences between Pointers and Arrays:
Aspect
Pointer
Array
Definition
A variable that retains an address
A collection of elements of identical type
Memory Allocation
Dynamic (using new/malloc)
Static (defined at compile time)
Can it be reassigned?
Yes, a pointer can refer to a different location
No, the array name is immutable
Arithmetic
Supports pointer arithmetic
Array name permits arithmetic, but itself cannot be altered
Size with sizeof
Returns the size of the pointer
Returns the total size of an array in bytes
Pointer Arithmetic in C++
Pointer arithmetic in C++ enables performing operations such as addition or subtraction on pointers to move through memory, which becomes particularly valuable while manipulating arrays.
Valid Pointer Operations:
Incrementing and Decrementing: ++ or — allows movement of the pointer to the subsequent or preceding element.
Adding an Integer: ptr + n permits advancing the pointer by n elements.
Subtracting an Integer: ptr – n allows the pointer to retreat by n elements.
Subtracting Two Pointers of the Same Type: It determines the count of elements between two pointers of identical type.
Pointer and NULL Comparison: It is utilized to ascertain whether a pointer is uninitialized or null (ptr == nullptr).
Example:
Cpp
Code Copied!
Output:
This example demonstrates how pointer arithmetic functions using a simple integer array for incrementing, decrementing, addition, subtraction, pointer difference, and null comparison.
Pointer to Pointer (Double Pointer) in C++
A pointer to a pointer is a variable that holds the address of another pointer. This enables indirect access to the value that a pointer points to. It is also referred to as a double pointer.
Syntax:
int x = 10; int* ptr = &x; // pointer to int int** dptr = &ptr; // pointer to pointer to int
Example:
Cpp
Code Copied!
var isMobile = window.innerWidth ");
editor69196.setValue(decodedContent); // Set the initial content
editor69196.clearSelection();
editor69196.setOptions({
maxLines: Infinity
});
function decodeHTML69196(input) {
var doc = new DOMParser().parseFromString(input, "text/html");
return doc.documentElement.textContent;
}
// Function to copy code to clipboard
function copyCodeToClipboard69196() {
const code = editor69196.getValue(); // Retrieve code from editor
navigator.clipboard.writeText(code).then(() => {
// alert("Code has been copied to clipboard!");
data: {
language: "cpp",
code: code,
cmd_line_args: "",
variablenames: "",
action: "compilerajax"
},
success: function(response) {
var myArray = response.split("~");
var data = myArray[1];
jQuery(".output69196").html("
"+data+"");
jQuery(".maineditor69196 .code-editor-output").show();
jQuery("#runBtn69196 i.run-code").hide();
}
})
}
function closeoutput69196() {
var code = editor69196.getSession().getValue();
jQuery(".maineditor69196 .code-editor-output").hide();
}
// Add event listeners to the buttons
document.getElementById("copyBtn69196").addEventListener("click", copyCodeToClipboard69196);
document.getElementById("runBtn69196").addEventListener("click", runCode69196);
document.getElementById("closeoutputBtn69196").addEventListener("click", closeoutput69196);
Output:
This example illustrates how a pointer stores the address of another pointer and facilitates accessing data indirectly; using **dptr retrieves the value, which then gets output to the console.
Pointer to Functions in C++
A pointer to a function allows storing the address of a function within a variable and invoking that function using the pointer. This is commonly utilized in callbacks, event handling, and function dispatching.
Syntax:
returnType (*pointerName)(parameterTypes);
Example:
Cpp
Code Duplicated!
var isMobile = window.innerWidth ");
editor64267.setValue(decodedContent); // Define the default text
editor64267.clearSelection();
editor64267.setOptions({
maxLines: Infinity
});
function decodeHTML64267(input) {
var doc = new DOMParser().parseFromString(input, "text/html");
return doc.documentElement.textContent;
}
// Function to replicate code to clipboard
function copyCodeToClipboard64267() {
const code = editor64267.getValue(); // Retrieve code from the editor
navigator.clipboard.writeText(code).then(() => {
jQuery(".maineditor64267 .copymessage").show();
setTimeout(function() {
jQuery(".maineditor64267 .copymessage").hide();
}, 2000);
}).catch(err => {
console.error("Error duplicating code: ", err);
});
}
function runCode64267() {
var code = editor64267.getSession().getValue();
jQuery.ajax({
url: "https://intellipaat.com/blog/wp-admin/admin-ajax.php",
type: "post",
data: {
language: "cpp",
code: code,
cmd_line_args: "",
variablenames: "",
action:"compilerajax"
},
success: function(response) {
var myArray = response.split("~");
var data = myArray[1];
jQuery(".output64267").html("
"+data+"");
jQuery(".maineditor64267 .code-editor-output").show();
jQuery("#runBtn64267 i.run-code").hide();
}
})
}
function closeoutput64267() {
var code = editor64267.getSession().getValue();
jQuery(".maineditor64267 .code-editor-output").hide();
}
// Attach event listeners to the buttons
document.getElementById("copyBtn64267").addEventListener("click", copyCodeToClipboard64267);
document.getElementById("runBtn64267").addEventListener("click", runCode64267);
document.getElementById("closeoutputBtn64267").addEventListener("click", closeoutput64267);
Result:
The code demonstrates how the function pointer retains the address of a function and invokes the address indirectly via the pointer funcPtr().
Smart Pointers in C++
Smart pointers are pointers in C++ utilized to autonomously manage dynamically allocated memory. It ensures proper deallocation and prevents memory leaks. They are included in the <memory> header in C++.
Three types of smart pointers exist. They are:
std::unique_ptr: A smart pointer that solely owns and manages a resource and cannot be shared or duplicated.
std::shared_ptr: Enables multiple pointers to jointly own a dynamically allocated object.
std::weak_ptr: A non-owning reference to an object managed by shared_ptr, used to prevent circular references.
Demonstration:
Cpp
Code Duplicated!
``````html
");
editor79923.setValue(decodedContent); // Assign the default text
editor79923.clearSelection();
editor79923.setOptions({
maxLines: Infinity
});
function decodeHTML79923(input) {
var doc = new DOMParser().parseFromString(input, "text/html");
return doc.documentElement.textContent;
}
// Function to transfer code to clipboard
function copyCodeToClipboard79923() {
const code = editor79923.getValue(); // Retrieve code from the editor
navigator.clipboard.writeText(code).then(() => {
// alert("Code copied to clipboard!");
jQuery(".maineditor79923 .copymessage").show();
setTimeout(function() {
jQuery(".maineditor79923 .copymessage").hide();
}, 2000);
}).catch(err => {
console.error("Error copying code: ", err);
});
}
function runCode79923() {
var code = editor79923.getSession().getValue();
jQuery("#runBtn79923 i.run-code").show();
jQuery(".output-tab").click();
jQuery.ajax({
url: "https://intellipaat.com/blog/wp-admin/admin-ajax.php",
type: "post",
data: {
language: "cpp",
code: code,
cmd_line_args: "",
variablenames: "",
action:"compilerajax"
},
success: function(response) {
var myArray = response.split("~");
var data = myArray[1];
jQuery(".output79923").html("
"+data+"");
jQuery(".maineditor79923 .code-editor-output").show();
jQuery("#runBtn79923 i.run-code").hide();
}
});
}
function closeoutput79923() {
var code = editor79923.getSession().getValue();
jQuery(".maineditor79923 .code-editor-output").hide();
}
// Attach event listeners to the buttons
document.getElementById("copyBtn79923").addEventListener("click", copyCodeToClipboard79923);
document.getElementById("runBtn79923").addEventListener("click", runCode79923);
document.getElementById("closeoutputBtn79923").addEventListener("click", closeoutput79923);
Output:
The code illustrates how the unique_ptr, shared_ptr, and weak_ptr demonstrate exclusive ownership, shared ownership, and non-owning reference with pointers, subsequently output to the console.
Pointer vs Reference in C++
Pointers are utilized to explicitly manage and manipulate memory addresses, capable of being reassigned or set to null, whereas references serve as variable aliases, being safer and more straightforward, but lacking the ability to be reassigned or set to null.
Below is a comparison chart for pointers versus references in C++:
Characteristic
Pointer
Reference
Syntax
int* ptr = &x;
int& ref = x;
Nullability
Can be nullptr
Cannot be null
Reassignment
Can point to another variable
Cannot be altered after binding
Indirection
Requires * for access
Utilized like the original variable
Memory Address
Stores address explicitly
Functions as an alias
Utilization in Arrays
Commonly associated with arrays
Less adaptable with arrays
Pointer and String Literals in C++
String literals in C++ are positioned as constant character arrays, and a pointer may be utilized to refer to them.
function closeoutput21178() {
var code = editor21178.getSession().getValue();
jQuery(".maineditor21178 .code-editor-output").hide();
}
// Bind event listeners to the buttons
document.getElementById("copyBtn21178").addEventListener("click", copyCodeToClipboard21178);
document.getElementById("runBtn21178").addEventListener("click", runCode21178);
document.getElementById("closeoutputBtn21178").addEventListener("click", closeoutput21178);
Output:
The code demonstrates how a pointer can refer to a string literal and retrieve individual characters from the string “Hello, World” using pointer arithmetic, then display it in the console.
Frequent Errors with Pointers in C++
Using a pointer that has not been initialized can cause undefined behavior.
Accessing memory through a null or already deallocated pointer may cause your program to crash.
Neglecting to free dynamically allocated memory can result in memory leaks.
Deleting the same memory twice can corrupt memory and crash the application.
An error in calculations can lead the pointer to point to invalid memory addresses.
Improper casting might result in incorrect values and segmentation faults.
Attempting to modify a string literal leads to undefined behavior.
Mishandling dereferencing and address-of operators can create logical errors.
Optimal Practices for Pointers in C++
Always initialize pointers to a valid address to prevent wild pointers.
Utilize smart pointers for efficient management of dynamic memory.
Opt for modern containers, like vector or string, to avoid direct usage of new and delete.
Always verify for nullptr before dereferencing to avoid invalid memory access.
Prefer array indexing and iterators for improved readability and reduced pointer arithmetic.
Limit the scope of pointers to ensure they are used only when necessary.
Employ const with pointers whenever possible to prevent inadvertent modification of the data.
Debugging Pointers in C++
The following methods can assist you in debugging pointers in C++:
1. Utilize Compiler Warnings and Flags
Compile your code using flags like -Wall -Wextra -pedantic to uncover potential pointer issues.
Activate sanitizers in your compiler with the following command.
g++ -fsanitize=address -g your_code.cpp
2. Check Initialization
Always initialize pointers to nullptr and validate before dereferencing.
3. Employ Debuggers
Utilize debuggers like GDB to set breakpoints and inspect memory addresses and pointer values using commands in bash.
gdb ./a.out (gdb) break main (gdb) run (gdb) print ptr (gdb) print *ptr
4. Utilize Valgrind
Employ Valgrind to detect memory leaks, invalid accesses, and pointer misuses.
valgrind ./a.out
Use Cases of Pointers in C++
Pointers are employed for memory management, system calls, and hardware access via memory-mapped input/output in operating systems.
They are also utilized in embedded systems for direct memory management and pointer arithmetic.
Pointers enhance performance in game development.
They facilitate the creation of data structures for dynamic connectivity and storage.
They play a vital role in networking for buffers and callback functions in asynchronous communication.
Pointers are significant in compilers and interpreters for processing symbol tables, syntax trees, and heap structures.
They’re used in GUI toolkits for event systems.
Pointers are essential in scientific computing for large dynamic arrays and matrix structures for performance and memory efficiency.
Pointers vs Iterators in C++
Aspect
Pointers
Iterators
Definition
Variables that hold memory addresses.
Objects used for traversing containers.
Syntax
int* ptr = &var;
auto it = container.begin();
Type Safety
Less type-safe, requires manual casting.
Type-safe, specific to containers.
Memory Management
Manual (new/delete).
Automatically managed by the container.
Use Case
Low-level memory access.
Traversing and modifying STL containers.
``````html
Direct access to memory.
Encapsulated access through container interface.
Mathematical Operations
Pointer operations permitted (ptr++).
Iterator operations using the container’s API (it++).
Container Compatibility
Arrays and memory allocated dynamically.
Compatible with STL containers.
Protection
Possibility of invalid access (null, out-of-bounds).
More secure, bounds-checked.
Efficiency
Highly efficient.
Marginally less efficient due to abstraction.
Adaptability
Extremely adaptable, but prone to errors.
More secure but less adaptable.
User-Friendliness
Demands additional caution.
More user-friendly, less prone to mistakes.
Summary
Pointers represent a robust aspect of C++ that facilitate direct memory access and proficient data manipulation. They have numerous practical applications, including in game development and data structures. Nonetheless, there are potential drawbacks and errors that may arise from improper pointer use. By grasping pointers, their applications, frequent errors, debugging methods, and optimal practices, you can effectively write C++ programs utilizing pointers.
Frequently Asked Questions about Pointers in C++
Q1. What is a pointer?
A pointer is a variable that holds the memory address of another variable.
Q2. What is nullptr?
A null pointer is one that does not reference any valid address.
Q3. What distinguishes a Pointer from a Reference?
The distinction lies in that a pointer can be reassigned and set to null, whereas a reference cannot.
Q4. What is a dangling pointer?
A dangling pointer points to memory that has been released or is out of scope.
Q5. What are the benefits of using smart pointers?
Smart pointers are beneficial for automatic memory management and for preventing memory leaks and dangling pointers.
To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions.
Functional
Always active
The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network.
Preferences
The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user.
Statistics
The technical storage or access that is used exclusively for statistical purposes.The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you.
Marketing
The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes.
