YouTipCpp Libs Vector Front
[ C++ Container Class ](#)
* * *
Among various operations of vector, `front` is a very simple function used to **get the first element**.
`front` is a member function of container class, used to **return the first element of the container**. It is equivalent to `at(0)` or `operator[](0)`, but with clearer semantics.
`front` provides an intuitive way to access the first element of the container.
**Word Definition**: `front` means "front", i.e., getting the first (frontmost) element.
* * *
## Basic Syntax and Parameters
`front` is a member function of container class, and calling it is very straightforward without any parameters.
### Syntax Format
reference front(); const_reference front() const;
### Parameter Description
* **Parameters**: No parameters
* `front` does not accept any parameters.
### Function Description
* **Return Value**: Returns a **reference** to the first element of the container. If the container is a constant container, it returns a const reference.
* **Effect**: Returns the first element (element at index 0) of the container.
* **Note**: Before calling `front`, ensure that the container is not empty; otherwise, the behavior is undefined. It is recommended to check using `empty()` or `size() > 0`.
* * *
## Examples
Let's go through a series of examples to fully master the usage of `front`.
### Example 1: Basic Usage - Get the First Element
## Example
#include
#include
int main(){
// 1. Create a vector and add some elements
std::vector numbers ={10, 20, 30, 40, 50};
std::cout<<"vector size is: "<< numbers.size()<< std::endl;
// 2. Use front to get the first element
std::cout<<"first element (front): "<< numbers.front()<< std::endl;
std::cout<<"using at(0): "<< numbers.at(0)<< std::endl;
std::cout<<"using : "<< numbers<< std::endl;
return 0;
}
**Expected Output:**
vector size is: 5first element (front): 10using at(0): 10using : 10
**Code Explanation:**
1. `numbers.front()` returns the first element `10`.
2. It returns the same value as `numbers.at(0)` and `numbers`, but with clearer semantics.
### Example 2: Modify the Value of the First Element
Since `front` returns a reference, it can be used to modify the value of the element.
## Example
#include
#include
#include
int main(){
std::vector names ={"Alice", "Bob", "Charlie"};
std::cout<<"Before modification, first element: "<< names.front()<< std::endl;
// Use front() to get a reference and modify the element
names.front()="Andrew";
std::cout<<"After modification, first element: "<< names.front()<< std::endl;
// Now names contains: Andrew, Bob, Charlie
return 0;
}
**Expected Output:**
Before modification, first element: AliceAfter modification, first element: Andrew
**Code Explanation:**
* `names.front() = "Andrew";` modifies the value of the first element via reference.
* `front()` returns a modifiable lvalue reference.
### Example 3: Safe Usage of front - Check if Container is Empty
Before using `front`, you should check whether the container is empty.
## Example
#include
#include
void printFront(const std::vector& v){
if(!v.empty()){
std::cout<<"First element is: "<< v.front()<< std::endl;
}
else{
std::cout<<"Container is empty, cannot get first element"<< std::endl;
}
}
int main(){
std::vector numbers ={10, 20, 30};
// Normal case
printFront(numbers);
// Empty container case
std::vector emptyVec;
printFront(emptyVec);
return 0;
}
**Expected Output:**
First element is: 10Container is empty, cannot get first element
**Code Explanation:**
* `!v.empty()` checks whether the container is not empty.
* Checking before calling `front` avoids undefined behavior.
### Example 4: Using front to Implement Queue Front
`front` can be used to implement a queue-like data structure.
## Example
#include
#include
#include
class SimpleQueue {
private:
std::vector data;
public:
// Enqueue
void enqueue(const std::string& item){
data.push_back(item);
}
// Dequeue (remove front element)
void dequeue(){
if(!data.empty()){
// Remove the first element, shift other elements forward
data.erase(data.begin());
}
}
// Get front element
std::string front()const{
if(!data.empty()){
return data.front();
}
return"";
}
// Check if queue is empty
bool empty()const{
return data.empty();
}
// Get queue size
size_t size()const{
return data.size();
}
};
int main(){
SimpleQueue q;
q.enqueue("User A");
q.enqueue("User B");
q.enqueue("User C");
std::cout<<"Queue size: "<< q.size()<< std::endl;
while(!q.empty()){
std::cout<<"Processing: "<< q.front()<< std::endl;
q.dequeue();
}
std::cout<<"Queue is now empty"<< std::endl;
return 0;
}
**Expected Output:**
Queue size: 3Processing: User A Processing: User B Processing: User C Queue is now empty
**Code Explanation:**
* `front()` is used to get the front element (the one waiting to be processed).
* This example shows how to use `front` to implement a first-in-first-out (FIFO) queue.
* * C++ Container Class ](#)