DEV Community: Anush

String Stream in C++

Anush — Sun, 09 Jun 2024 05:31:15 +0000

What is Stringstream Class in C++?

stringstream is a part of the C++ Standard Library, included in the sstream header, and is used for performing input and output operations on strings. It allows you to treat a string like a stream (such as cin or cout), enabling formatted input and output operations.

Commonly Used Methods of Stringstream Class in C++

clear() :- To clear the stream.
str() :- To get and set string object whose content is present in the stream.
operator << :- Add a string to the stringstream object.
operator >> :- Read something from the stringstream object.



#include <iostream>
#include <sstream>
#include <string>

using namespace std;

int main() {
    // Create a stringstream object
    stringstream ss;

    // Using operator<< to add data to the stringstream
    ss << "123 456 789";

    // Output the current content of the stringstream using str()
    cout << "Initial stringstream content: " << ss.str() << endl;

    // Variables to hold extracted values
    int a, b, c;

    // Using operator>> to extract data from the stringstream
    ss >> a >> b >> c;

    // Display the extracted values
    cout << "Extracted values: " << a << " " << b << " " << c << endl;

    // Clear the stringstream using clear()
    ss.clear();

    // Check the content after clearing (should be empty)
    cout << "After clear() - current stringstream content: " << ss.str() << endl;

    // Set a new string to the stringstream using str()
    ss.str("987 654 321");

    // Output the new content of the stringstream
    cout << "After str() set new content: " << ss.str() << endl;

    // Extract data from the stringstream again
    ss >> a >> b >> c;

    // Display the newly extracted values
    cout << "Newly extracted values: " << a << " " << b << " " << c << endl;

    // Clear the stringstream and reset the stringstream content
    ss.clear();
    ss.str("");

    // Verify that the stringstream is cleared
    cout << "Final stringstream content after clear and str reset: '" << ss.str() << "'" << endl;

    return 0;
}

n represents the size of the string content in the stream, and m represents the size of the data being inserted or extracted.



// C++ program to demonstrate use of stringstream to count frequencies of words.
#include <bits/stdc++.h>

using namespace std;

void printFrequency(string st)
{
    // Each word it mapped to it's frequency
    map<string, int> FW;

    // Used for breaking words
    stringstream ss(st);

    // To store individual words
    string Word;

    while (ss >> Word)
        FW[Word]++;

    for (auto m : FW)
        cout << m.first << "-> " << m.second << "\n";
}


int main()
{
    string s = "May the force be with you";
    printFrequency(s);
    return 0;
}

NVM Install On Your PC

Anush — Sun, 02 Jun 2024 15:05:26 +0000

NVM (Node Version Manager) is a popular tool for managing multiple versions of Node.js on a single machine. Here are some important commands for NVM:

Installation Commands

Install NVM:

 curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.3/install.sh | bash

This script installs the latest version of NVM. Replace `v0.

NVM (Node Version Manager) Important Commands

Installation

Install NVM:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.3/install.sh | bash

This command downloads and runs the NVM install script from the NVM GitHub repository.

Load NVM:

export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")" [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"

This is usually added to your shell profile file (~/.bashrc, ~/.zshrc, etc.) to load NVM when you open a new terminal.

Basic Usage

Check NVM Version:

nvm --version

List Installed Node Versions:

nvm ls

List Available Node Versions:
nvm ls-remote
Install a Specific Node Version:

nvm install <version>

Replace <version> with the desired version number, e.g., nvm install 16.13.0.

Use a Specific Node Version:

nvm use <version>

Replace <version> with the installed version number you want to use.

Set Default Node Version:

nvm alias default <version>

This sets the default Node.js version to be used in new shell sessions.

Uninstall a Specific Node Version:

nvm uninstall <version>

Show Current Node Version:
nvm current
Run Node with a Specific Version:

nvm run <version> <script.js>

Replace `<version>` with the Node.js version and `<script.js>` with the script you want to run.

Execute NPM Commands with Specific Node Version:
nvm exec <version> npm <command>

For example, nvm exec 14.17.0 npm install.
Reinstall Packages from Current Version:
nvm reinstall-packages <version>

This reinstalls global packages from the specified version into the current version.
Get Help:

nvm help

These commands cover the essential functionality of NVM, helping you to manage different Node.js versions efficiently.

Setting Up Project React and TypeScript Application with Vite and Tailwind CSS

Anush — Sun, 02 Jun 2024 14:43:46 +0000

Prerequisites
Node.js installed on your machine

Steps
1. Create a New Project with Vite
First, create a new React project using Vite. Open your terminal and run the following commands:

npm create vite@latest my-react-app -- --template react-ts
cd my-react-app
npm install

2. Install Tailwind CSS
Next, install Tailwind CSS and its dependencies:

npm install -D tailwindcss postcss autoprefixer
npx tailwindcss init -p

3. Configure Tailwind CSS
Replace the contents of tailwind.config.cjs with the following configuration:

module.exports = {
  content: [
    "./index.html",
    "./src/**/*.{js,ts,jsx,tsx}",
  ],
  theme: {
    extend: {},
  },
  plugins: [],
}

4. Add Tailwind Directives to Your CSS
Add the following directives to your src/index.css file:

@tailwind base;
@tailwind components;
@tailwind utilities;

5. Start the Development Server
Finally, start the development server to see your project in action:

npm run dev

String Vs StringBuffer Vs StringBuilder in Java 💪

Anush — Wed, 28 Feb 2024 13:58:03 +0000

String, StringBuffer, and StringBuilder are three classes used for string manipulation, but they differ in terms of mutability, synchronization, and performance characteristics:

String:

Immutable: Once a String object is created, its value cannot be changed.
Thread-safe: Immutable strings are inherently thread-safe.
Memory efficiency: Because strings are immutable, modifying them (e.g., concatenation) creates new string objects, potentially leading to memory overhead, especially in scenarios with frequent string manipulation.
Suitable for scenarios where the value of the string remains constant or changes infrequently.

StringBuffer:

Mutable: StringBuffer objects can be modified after creation.
Thread-safe: StringBuffer methods are synchronized, making them safe for use in multithreaded environments.
Performance: Slower than StringBuilder due to synchronization.
Suitable for scenarios where thread safety is required, such as in multithreaded applications or when concurrent access to strings is necessary

StringBuilder:

Mutable: StringBuilder objects can be modified after creation.
Not thread-safe: StringBuilder methods are not synchronized, making them unsuitable for concurrent use in multithreaded environments.
Performance: Faster than StringBuffer because it lacks synchronization overhead.
Suitable for single-threaded scenarios where high-performance string manipulation is required, such as string concatenation within loops or when building strings dynamically.


public class StringExample {
    public static void main(String[] args) {
        // Example of String
        String str = "Hello";
        str += " World"; // Concatenating " World" to the original string
        System.out.println("String: " + str); // Output: Hello World

        // Example of StringBuffer
        StringBuffer stringBuffer = new StringBuffer("Hello");
        stringBuffer.append(" World"); // Appending " World" to the original string
        System.out.println("StringBuffer: " + stringBuffer.toString()); // Output: Hello World

        // Example of StringBuilder
        StringBuilder stringBuilder = new StringBuilder("Hello");
        stringBuilder.append(" World"); // Appending " World" to the original string
        System.out.println("StringBuilder: " + stringBuilder.toString()); // Output: Hello World
    }
}

Here's a summary of their characteristics:

In summary, String is immutable and thread-safe, StringBuffer is mutable and thread-safe, and StringBuilder is mutable but not thread-safe. You should choose the appropriate class based on your specific requirements for mutability, thread safety, and performance.

How Java Works? 🚀

Anush — Mon, 26 Feb 2024 15:03:11 +0000

1.Compilation:

Java source code is written in human-readable form by developers. This source code typically resides in files with a .java extension.
The Java compiler (javac) translates the source code into platform-independent bytecode. Bytecode is a set of instructions for the Java Virtual Machine (JVM) and is stored in files with a .class extension.

2.Java Virtual Machine (JVM):

The JVM is a virtual machine that provides an execution environment for Java bytecode.
When a Java program is executed, the JVM loads the bytecode files generated by the compiler.
It then interprets the bytecode instructions and translates them into native machine code instructions that are specific to the underlying hardware and operating system. This translation can be done dynamically during program execution using techniques like Just-In-Time (JIT) compilation.
The JVM also manages memory allocation and deallocation, garbage collection, exception handling, and other runtime tasks.

3.Execution:

Once the bytecode is loaded and translated by the JVM, the Java program begins execution.
The JVM follows the instructions provided by the bytecode, executing the program's logic step by step.
Java applications can interact with the underlying system through APIs provided by the Java standard library and other libraries.

Difference between Compiled and Interpreted Language

Anush — Mon, 26 Feb 2024 13:23:02 +0000

Compiled and interpreted languages are two different approaches to executing code:

Compiled Language:

In a compiled language, the source code is translated entirely into machine code (binary) before execution.
This translation process is done by a compiler, which converts the entire source code into an executable file or another form of machine code.
The resulting compiled code is usually specific to the target platform (such as a particular operating system and processor architecture).
Examples of compiled languages include C, C++, Rust, and Go.

Interpreted language

In an interpreted language, the source code is executed line-by-line or statement-by-statement without the need for a separate compilation step.
Instead of compiling the entire source code into machine code beforehand, an interpreter reads each line of the source code and executes it directly.
This allows for more dynamic behavior as code can be modified and executed on-the-fly.
Interpreted languages are often platform-independent since the interpreter itself abstracts away the underlying hardware.
Examples of interpreted languages include Python, JavaScript, Ruby, and PHP.

Here are some key differences between the two:

Execution Speed: Compiled languages generally execute faster because the entire code is translated into machine code upfront. Interpreted languages may have a slight overhead as each line of code is translated and executed sequentially.
Portability: Interpreted languages are usually more portable because they can run on any platform with the appropriate interpreter. Compiled languages often require recompilation for different platforms.
Debugging: Debugging compiled languages can sometimes be more challenging because the source code isn't directly executed. In interpreted languages, debugging can be more straightforward as you can inspect the code during runtime.
Development Cycle: Compiled languages typically have a longer development cycle due to the compilation step. Interpreted languages offer a shorter development cycle since there's no separate compilation step required.

Both approaches have their advantages and are suited to different tasks and preferences. Some languages, like Java, utilize a combination of both compilation and interpretation through the use of bytecode and a virtual machine

Note:-
Java is often described as a "compiled" language, but it's more accurate to say that Java uses a combination of compilation and interpretation.
Here's how it works:

1.Compilation to Bytecode:

Java source code is first compiled into an intermediate form called bytecode. This compilation step is done by the Java compiler (javac), which translates the human-readable Java source code into platform-independent bytecode instructions.
Bytecode is not machine code; instead, it's a set of instructions for the Java Virtual Machine (JVM) to execute.

2.Interpretation by the Java Virtual Machine (JVM):

After compilation, the bytecode is executed by the Java Virtual Machine (JVM). The JVM is a runtime environment that interprets bytecode and manages memory, security, and other runtime aspects of Java programs.
The JVM translates bytecode into native machine code instructions specific to the underlying hardware and operating system on which it's running. This translation is done dynamically during program execution.
Additionally, modern JVM implementations often employ Just-In-Time (JIT) compilation techniques. JIT compilation involves translating frequently executed bytecode sequences into native machine code for improved performance.