Convert Java to C++

Convert Java code to idiomatic C++. This skill extends meta-convert-dev with Java-to-C++ specific type mappings, idiom translations, and tooling.

This Skill Extends

• meta-convert-dev - Foundational conversion patterns (APTV workflow, testing strategies)

For general concepts like the Analyze → Plan → Transform → Validate workflow, testing strategies, and common pitfalls, see the meta-skill first.

This Skill Adds

• Type mappings: Java types → C++ types
• Idiom translations: Java patterns → idiomatic C++
• Error handling: Java exceptions → C++ exception handling and RAII
• Memory management: Java GC → C++ manual memory management and smart pointers
• Concurrency: Java threads → C++ threading and async patterns
• Build systems: Maven/Gradle → CMake/Make

This Skill Does NOT Cover

• General conversion methodology - see meta-convert-dev
• Java language fundamentals - see lang-java-dev
• C++ language fundamentals - see lang-cpp-dev
• Reverse conversion (C++ → Java) - see convert-cpp-java

---

Quick Reference

Java	C++	Notes
String	std::string	Owned string
int	int / int32_t	32-bit signed integer
long	long / int64_t	64-bit signed integer
double	double	64-bit float
boolean	bool	Boolean type
Object	void* / templates	Avoid void*, use templates
List<T>	std::vector<T>	Dynamic array
Set<T>	std::set<T> / std::unordered_set<T>	Ordered/unordered set
Map<K, V>	std::map<K, V> / std::unordered_map<K, V>	Ordered/unordered map
Optional<T>	std::optional<T>	Nullable value (C++17)
Stream<T>	Range views (C++20) / iterators	Lazy evaluation
interface	class (abstract)	Pure virtual functions
class	class / struct	Similar but different memory model
package	namespace	Code organization
synchronized	std::mutex + std::lock_guard	Thread safety

When Converting Code

1. Analyze source thoroughly before writing target
2. Map types first - create type equivalence table
3. Preserve semantics over syntax similarity
4. Adopt C++ idioms - don't write "Java code in C++ syntax"
5. Handle memory explicitly - GC → RAII and smart pointers
6. Test equivalence - same inputs → same outputs

---

Type System Mapping

Primitive Types

Java	C++	Notes
byte	int8_t / char	8-bit signed
short	int16_t / short	16-bit signed
int	int / int32_t	32-bit signed
long	long long / int64_t	64-bit signed
float	float	32-bit floating point
double	double	64-bit floating point
char	char16_t / wchar_t	16-bit Unicode in Java, varies in C++
boolean	bool	Boolean type
void	void	No return value

Collection Types

Java	C++	Notes
ArrayList<T>	std::vector<T>	Dynamic array, contiguous memory
LinkedList<T>	std::list<T>	Doubly-linked list
HashSet<T>	std::unordered_set<T>	Hash-based set, O(1) lookup
TreeSet<T>	std::set<T>	Sorted set, O(log n) lookup
HashMap<K, V>	std::unordered_map<K, V>	Hash-based map, O(1) lookup
TreeMap<K, V>	std::map<K, V>	Sorted map, O(log n) lookup
Queue<T>	std::queue<T>	FIFO queue
Stack<T>	std::stack<T>	LIFO stack
Deque<T>	std::deque<T>	Double-ended queue
T[]	std::array<T, N> / std::vector<T>	Fixed/dynamic array

Composite Types

Java	C++	Notes
class	class	Classes with constructors/destructors
interface	class with pure virtuals	Abstract base class
abstract class	class with virtuals	Base class with implementation
enum	enum class	Strongly-typed enum (C++11)
@interface (annotation)	Attributes (C++11)	Limited compared to Java
record (Java 14+)	struct	Immutable data class
sealed class (Java 17+)	final class	Restrict inheritance

Generic Type Mappings

Java	C++	Notes
<T>	template<typename T>	Generic type parameter
<T extends Base>	template<typename T> + static_assert	Type constraints
<T extends A & B>	Concepts (C++20)	Multiple constraints
<? extends T>	const T& / T	Upper bound wildcard
<? super T>	-	No direct equivalent
List<?>	Templates + type erasure	Complex pattern

Special Mappings

Java	C++	Notes
Object	std::any (C++17) / templates	Prefer templates
null	nullptr	Null pointer
Optional<T>	std::optional<T> (C++17)	Nullable value
String	std::string	UTF-8 string
StringBuilder	std::ostringstream / std::string	String building
Comparable<T>	operator<	Comparison operator
Iterable<T>	Iterator pattern	Range-for compatible
Runnable	std::function<void()> / lambda	Callable object
Callable<T>	std::function<T()> / lambda	Callable with return

---

Module System Translation

Package → Namespace

Java:

package com.example.myapp;

public class User {
    private String name;
    private int age;
}

C++:

// user.hpp
#ifndef COM_EXAMPLE_MYAPP_USER_HPP
#define COM_EXAMPLE_MYAPP_USER_HPP

#include <string>

namespace com::example::myapp {

class User {
private:
    std::string name;
    int age;

public:
    User(const std::string& name, int age);
    // Getters/setters
};

}  // namespace com::example::myapp

#endif

Why this translation:

• Java packages map to C++ namespaces (use :: separator in C++17+)
• Header guards (#ifndef) prevent multiple inclusion
• Declarations in .hpp, definitions in .cpp

Import → Include

Java:

import java.util.List;
import java.util.ArrayList;
import java.util.stream.*;

C++:

#include <vector>
#include <algorithm>
#include <ranges>  // C++20

Why this translation:

• Java imports map to C++ includes
• C++ uses header files, not package-based imports
• Standard library in <>, local files in ""

Visibility Modifiers

Java	C++	Notes
public	public:	Accessible everywhere
protected	protected:	Accessible in class and subclasses
private	private:	Accessible only in class
package-private (default)	-	No direct equivalent, use unnamed namespace

---

Idiom Translation

Pattern 1: Getter/Setter → Direct Access or Property

Java:

public class User {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative");
        }
        this.age = age;
    }
}

C++:

class User {
private:
    std::string name;
    int age;

public:
    // Const getters
    const std::string& getName() const { return name; }
    int getAge() const { return age; }

    // Setters with validation
    void setName(const std::string& name) { this->name = name; }

    void setAge(int age) {
        if (age < 0) {
            throw std::invalid_argument("Age cannot be negative");
        }
        this->age = age;
    }
};

Why this translation:

• C++ uses const methods for getters (promise not to modify object)
• Return const& for large objects to avoid copying
• Throw standard exceptions (std::invalid_argument, etc.)

Pattern 2: Null Handling → Optional/Smart Pointers

Java:

public User findUser(String id) {
    for (User user : users) {
        if (user.getId().equals(id)) {
            return user;
        }
    }
    return null;
}

// Usage
User user = findUser("123");
if (user != null) {
    System.out.println(user.getName());
}

C++:

std::optional<User> findUser(const std::string& id) {
    auto it = std::find_if(users.begin(), users.end(),
        [&id](const User& u) { return u.getId() == id; });

    if (it != users.end()) {
        return *it;
    }
    return std::nullopt;
}

// Usage
auto user = findUser("123");
if (user.has_value()) {
    std::cout << user->getName() << '\n';
}

// Or with value_or
auto name = findUser("123")
    .transform([](const User& u) { return u.getName(); })
    .value_or("Unknown");

Why this translation:

• std::optional makes null handling explicit (C++17)
• Safer than raw pointers for optional values
• Supports functional-style operations (transform, value_or)

Pattern 3: Collection Operations → STL Algorithms/Ranges

Java:

List<Integer> result = items.stream()
    .filter(x -> x % 2 == 0)
    .map(x -> x * 2)
    .collect(Collectors.toList());

C++:

// Traditional STL algorithms
std::vector<int> result;
std::copy_if(items.begin(), items.end(), std::back_inserter(result),
    [](int x) { return x % 2 == 0; });
std::transform(result.begin(), result.end(), result.begin(),
    [](int x) { return x * 2; });

// Or with C++20 ranges (more similar to Java)
auto result = items
    | std::views::filter([](int x) { return x % 2 == 0; })
    | std::views::transform([](int x) { return x * 2; })
    | std::ranges::to<std::vector>();

Why this translation:

• C++20 ranges provide lazy evaluation like Java streams
• Traditional STL algorithms are more verbose but work in older C++
• Ranges compose better and are more readable

Pattern 4: Try-with-Resources → RAII

Java:

try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    String line = reader.readLine();
    // Use line
} catch (IOException e) {
    e.printStackTrace();
}
// reader is automatically closed

C++:

// RAII - Resource Acquisition Is Initialization
#include <fstream>
#include <string>

try {
    std::ifstream file("file.txt");
    if (!file.is_open()) {
        throw std::runtime_error("Failed to open file");
    }

    std::string line;
    std::getline(file, line);
    // Use line
    // file is automatically closed when it goes out of scope
} catch (const std::exception& e) {
    std::cerr << e.what() << '\n';
}

Why this translation:

• C++ uses RAII pattern - resources cleaned up in destructors
• No need for explicit close() - automatic when object destroyed
• More general than Java's try-with-resources

Pattern 5: Interfaces → Abstract Classes with Pure Virtuals

Java:

public interface Drawable {
    void draw();

    default void render() {
        System.out.println("Rendering...");
        draw();
    }
}

public class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing circle");
    }
}

C++:

class Drawable {
public:
    // Pure virtual function (must be implemented)
    virtual void draw() = 0;

    // Virtual function with default implementation
    virtual void render() {
        std::cout << "Rendering...\n";
        draw();
    }

    // Virtual destructor (important!)
    virtual ~Drawable() = default;
};

class Circle : public Drawable {
public:
    void draw() override {
        std::cout << "Drawing circle\n";
    }
};

Why this translation:

• Pure virtual functions (= 0) = Java abstract methods
• Virtual functions with body = Java default methods
• Always provide virtual destructor for polymorphic classes
• Use override keyword for safety (C++11)

Pattern 6: Inheritance → Composition (Preferred in C++)

Java:

public class Stack<T> extends ArrayList<T> {
    public void push(T item) {
        add(item);
    }

    public T pop() {
        return remove(size() - 1);
    }
}

C++:

// Prefer composition over inheritance
template<typename T>
class Stack {
private:
    std::vector<T> data;

public:
    void push(const T& item) {
        data.push_back(item);
    }

    T pop() {
        if (data.empty()) {
            throw std::runtime_error("Stack is empty");
        }
        T item = std::move(data.back());
        data.pop_back();
        return item;
    }

    bool empty() const {
        return data.empty();
    }

    size_t size() const {
        return data.size();
    }
};

Why this translation:

• Composition is more flexible than inheritance in C++
• Avoids exposing base class interface
• Better encapsulation and type safety

---

Error Handling

Exception Mapping

Java Exception	C++ Exception	Notes
Exception	std::exception	Base exception class
RuntimeException	std::runtime_error	Runtime errors
IllegalArgumentException	std::invalid_argument	Invalid argument
IllegalStateException	std::logic_error	Logic error
NullPointerException	std::bad_optional_access	Null access (or use optional)
IndexOutOfBoundsException	std::out_of_range	Array bounds
IOException	std::ios_base::failure	I/O error
ArithmeticException	std::overflow_error	Arithmetic error

Exception Handling Patterns

Java:

public int divide(int a, int b) throws ArithmeticException {
    if (b == 0) {
        throw new ArithmeticException("Division by zero");
    }
    return a / b;
}

public void process() {
    try {
        int result = divide(10, 0);
    } catch (ArithmeticException e) {
        System.err.println("Error: " + e.getMessage());
    } finally {
        cleanup();
    }
}

C++:

int divide(int a, int b) {
    if (b == 0) {
        throw std::invalid_argument("Division by zero");
    }
    return a / b;
}

void process() {
    try {
        int result = divide(10, 0);
    } catch (const std::invalid_argument& e) {
        std::cerr << "Error: " << e.what() << '\n';
    }
    // No finally - use RAII for cleanup
}

// RAII handles cleanup automatically
class Resource {
public:
    Resource() { /* acquire */ }
    ~Resource() { cleanup(); }  // Always called
};

Why this translation:

• C++ doesn't have finally - use RAII instead
• Catch by const& to avoid slicing
• Throw standard exceptions or custom types
• No checked exceptions in C++

Custom Exceptions

Java:

public class ValidationException extends Exception {
    public ValidationException(String message) {
        super(message);
    }
}

C++:

class ValidationException : public std::exception {
private:
    std::string message;

public:
    explicit ValidationException(const std::string& msg) : message(msg) {}

    const char* what() const noexcept override {
        return message.c_str();
    }
};

---

Memory Management

Java GC → C++ Manual Memory

Java (GC):

public class DataProcessor {
    private List<Data> cache = new ArrayList<>();

    public void addData(Data data) {
        cache.add(data);  // GC handles cleanup
    }
}

C++ (RAII + Smart Pointers):

class DataProcessor {
private:
    std::vector<std::shared_ptr<Data>> cache;

public:
    void addData(std::shared_ptr<Data> data) {
        cache.push_back(data);
        // Automatically cleaned up when last shared_ptr is destroyed
    }

    // Or with unique ownership
    void addDataUnique(std::unique_ptr<Data> data) {
        cache.push_back(std::move(data));
    }
};

Smart Pointer Decision Tree

Is the object optional/nullable?
├─ YES → std::optional<T> (if small) or std::unique_ptr<T> (if large/polymorphic)
└─ NO → Direct member (T) or reference (T&)

Does the object need shared ownership?
├─ YES → std::shared_ptr<T>
└─ NO → std::unique_ptr<T> or direct ownership

Is the object polymorphic (virtual functions)?
├─ YES → Must use pointers (raw, unique, or shared)
└─ NO → Can use direct value

Memory Ownership Patterns

Java (Shared References):

public class Cache {
    private Map<String, User> users = new HashMap<>();

    public User getUser(String id) {
        return users.get(id);  // Returns reference, GC handles lifetime
    }

    public void setUser(String id, User user) {
        users.put(id, user);  // Stores reference
    }
}

C++ (Explicit Ownership):

class Cache {
private:
    std::unordered_map<std::string, std::shared_ptr<User>> users;

public:
    // Return shared pointer - shared ownership
    std::shared_ptr<User> getUser(const std::string& id) {
        auto it = users.find(id);
        if (it != users.end()) {
            return it->second;
        }
        return nullptr;
    }

    // Or return optional reference - no ownership transfer
    std::optional<std::reference_wrapper<const User>>
    getUserRef(const std::string& id) const {
        auto it = users.find(id);
        if (it != users.end()) {
            return *it->second;
        }
        return std::nullopt;
    }

    void setUser(const std::string& id, std::shared_ptr<User> user) {
        users[id] = user;
    }
};

Why this translation:

• C++ requires explicit ownership decisions
• Shared pointers for shared ownership (reference counting)
• References for borrowing without ownership transfer
• Unique pointers for exclusive ownership

---

Concurrency Patterns

Thread Creation

Java:

Thread thread = new Thread(() -> {
    System.out.println("Running in thread");
});
thread.start();
thread.join();

C++:

#include <thread>
#include <iostream>

std::thread thread([]() {
    std::cout << "Running in thread\n";
});
thread.join();

Synchronized → Mutex

Java:

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

C++:

#include <mutex>

class Counter {
private:
    int count = 0;
    mutable std::mutex mtx;

public:
    void increment() {
        std::lock_guard<std::mutex> lock(mtx);
        count++;
    }

    int getCount() const {
        std::lock_guard<std::mutex> lock(mtx);
        return count;
    }
};

Why this translation:

• std::lock_guard provides RAII locking (like Java synchronized)
• Automatically unlocks when scope ends
• Use mutable for mutex in const methods

ExecutorService → std::async/thread pool

Java:

ExecutorService executor = Executors.newFixedThreadPool(4);

Future<String> future = executor.submit(() -> {
    Thread.sleep(1000);
    return "Result";
});

String result = future.get();
executor.shutdown();

C++:

#include <future>
#include <thread>
#include <chrono>

// Simple async
std::future<std::string> future = std::async(std::launch::async, []() {
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    return std::string("Result");
});

std::string result = future.get();

// For thread pools, use external library (e.g., Boost.Asio, Thread Pool)

CompletableFuture → std::future/promise

Java:

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    return fetchData();
});

future.thenApply(data -> parse(data))
      .thenAccept(result -> process(result))
      .exceptionally(ex -> handleError(ex));

C++:

// C++ std::future is more limited
auto future = std::async(std::launch::async, []() {
    return fetchData();
});

try {
    auto data = future.get();
    auto result = parse(data);
    process(result);
} catch (const std::exception& ex) {
    handleError(ex);
}

// For chaining, use external library (e.g., folly::Future, boost::future)

---

Metaprogramming

Annotations → Attributes

Java:

@Override
public String toString() {
    return "User";
}

@Deprecated
public void oldMethod() {
    // ...
}

@SuppressWarnings("unchecked")
public List getRawList() {
    // ...
}

C++:

// C++11 attributes (limited compared to Java)
[[nodiscard]] int getValue() {
    return 42;
}

[[deprecated("Use newMethod instead")]]
void oldMethod() {
    // ...
}

[[maybe_unused]] void utilityFunction() {
    // ...
}

// C++20 attributes
[[likely]]
if (condition) {
    // Likely branch
}

[[unlikely]]
else {
    // Unlikely branch
}

Why this translation:

• C++ attributes are compiler hints, not runtime-accessible
• Much more limited than Java annotations
• No custom attributes like Java's annotation processing

Reflection → Runtime Type Information (Limited)

Java:

Class<?> clazz = obj.getClass();
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
    System.out.println(method.getName());
}

C++:

#include <typeinfo>

// Very limited reflection
const std::type_info& ti = typeid(obj);
std::cout << "Type: " << ti.name() << '\n';

// For more reflection, use external libraries:
// - Boost.PFR (Plain Old Data reflection)
// - rttr (Run-Time Type Reflection)
// - Meta Stuff (modern reflection library)

Note: C++ has minimal runtime reflection. Most "reflection" done at compile-time with templates.

Generics → Templates

Java:

public class Box<T> {
    private T value;

    public void set(T value) {
        this.value = value;
    }

    public T get() {
        return value;
    }
}

Box<String> box = new Box<>();

C++:

template<typename T>
class Box {
private:
    T value;

public:
    void set(const T& value) {
        this->value = value;
    }

    const T& get() const {
        return value;
    }
};

Box<std::string> box;

Why this translation:

• C++ templates are more powerful (compile-time vs runtime)
• Templates fully instantiated at compile-time
• No type erasure in C++ (unlike Java)

---

Serialization

Jackson → Third-Party Libraries

Java:

import com.fasterxml.jackson.databind.ObjectMapper;

public class User {
    @JsonProperty("user_id")
    private String id;
    private String name;

    @JsonIgnore
    private String password;
}

ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(user);
User parsed = mapper.readValue(json, User.class);

C++:

// Using nlohmann/json library
#include <nlohmann/json.hpp>

struct User {
    std::string id;
    std::string name;
    std::string password;  // Will handle separately
};

// Define serialization
void to_json(nlohmann::json& j, const User& u) {
    j = {
        {"user_id", u.id},
        {"name", u.name}
        // password omitted
    };
}

void from_json(const nlohmann::json& j, User& u) {
    j.at("user_id").get_to(u.id);
    j.at("name").get_to(u.name);
}

// Usage
nlohmann::json j = user;
std::string json_str = j.dump();

User parsed = j.get<User>();

Popular C++ JSON libraries:

• nlohmann/json - Modern, easy to use
• RapidJSON - Fast, SAX/DOM parsing
• simdjson - Extremely fast parsing
• Boost.JSON - Part of Boost

Validation

Java:

import jakarta.validation.constraints.*;

public class User {
    @NotNull
    @Size(min = 1, max = 100)
    private String name;

    @Email
    private String email;

    @Min(0)
    @Max(150)
    private int age;
}

C++:

// Manual validation or use external library
class User {
private:
    std::string name;
    std::string email;
    int age;

public:
    User(std::string name, std::string email, int age) {
        if (name.empty() || name.length() > 100) {
            throw std::invalid_argument("Name must be 1-100 characters");
        }
        if (age < 0 || age > 150) {
            throw std::invalid_argument("Age must be 0-150");
        }
        // Email validation with regex
        std::regex email_regex(R"([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})");
        if (!std::regex_match(email, email_regex)) {
            throw std::invalid_argument("Invalid email");
        }

        this->name = std::move(name);
        this->email = std::move(email);
        this->age = age;
    }
};

---

Build System Translation

Maven/Gradle → CMake

Maven (pom.xml):

<project>
    <groupId>com.example</groupId>
    <artifactId>myapp</artifactId>
    <version>1.0.0</version>

    <dependencies>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>32.0.0</version>
        </dependency>
    </dependencies>
</project>

CMake (CMakeLists.txt):

cmake_minimum_required(VERSION 3.20)
project(myapp VERSION 1.0.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Dependencies
find_package(Boost REQUIRED)

add_executable(myapp
    src/main.cpp
    src/utils.cpp
)

target_include_directories(myapp PRIVATE
    ${CMAKE_CURRENT_SOURCE_DIR}/include
)

target_link_libraries(myapp PRIVATE
    Boost::boost
)

# Tests
enable_testing()
add_subdirectory(tests)

Dependency Management

Java	C++	Notes
Maven Central	vcpkg / Conan / Hunter	Package managers
pom.xml	CMakeLists.txt	Build config
.jar files	.a / .so / .dll	Libraries
Modules (Java 9+)	Header files	Module system

---

Testing

JUnit → Google Test / Catch2

Java (JUnit):

import org.junit.jupiter.api.*;

class CalculatorTest {
    private Calculator calc;

    @BeforeEach
    void setUp() {
        calc = new Calculator();
    }

    @Test
    void shouldAddNumbers() {
        assertEquals(5, calc.add(2, 3));
    }

    @Test
    void shouldThrowOnDivideByZero() {
        assertThrows(ArithmeticException.class, () -> {
            calc.divide(10, 0);
        });
    }
}

C++ (Google Test):

#include <gtest/gtest.h>
#include "calculator.hpp"

class CalculatorTest : public ::testing::Test {
protected:
    void SetUp() override {
        calc = std::make_unique<Calculator>();
    }

    std::unique_ptr<Calculator> calc;
};

TEST_F(CalculatorTest, ShouldAddNumbers) {
    EXPECT_EQ(5, calc->add(2, 3));
}

TEST_F(CalculatorTest, ShouldThrowOnDivideByZero) {
    EXPECT_THROW(calc->divide(10, 0), std::invalid_argument);
}

Mockito → Google Mock

Java (Mockito):

@Mock
private UserRepository repo;

@Test
void shouldFindUser() {
    when(repo.findById(1L)).thenReturn(Optional.of(user));

    User result = service.getUser(1L);

    verify(repo).findById(1L);
    assertEquals("Alice", result.getName());
}

C++ (Google Mock):

class MockUserRepository : public UserRepository {
public:
    MOCK_METHOD(std::optional<User>, findById, (int64_t id), (override));
};

TEST(UserServiceTest, ShouldFindUser) {
    MockUserRepository repo;
    UserService service(repo);
    User expected{"Alice", 30};

    EXPECT_CALL(repo, findById(1))
        .WillOnce(::testing::Return(expected));

    auto result = service.getUser(1);
    EXPECT_EQ("Alice", result.getName());
}

---

Common Pitfalls

1. Object Slicing

Problem:

class Base {
public:
    virtual void print() { std::cout << "Base\n"; }
};

class Derived : public Base {
    int extra;
public:
    void print() override { std::cout << "Derived\n"; }
};

void process(Base obj) {  // Takes by value - SLICING!
    obj.print();  // Always prints "Base"
}

Derived d;
process(d);  // Derived object sliced to Base

Fix:

void process(const Base& obj) {  // Take by reference
    obj.print();  // Polymorphic behavior
}

2. Forgetting Virtual Destructors

Problem:

class Base {
public:
    ~Base() { /* cleanup */ }  // Not virtual!
};

class Derived : public Base {
    int* data;
public:
    ~Derived() { delete[] data; }  // Never called!
};

Base* ptr = new Derived();
delete ptr;  // Undefined behavior - Derived destructor not called

Fix:

class Base {
public:
    virtual ~Base() { /* cleanup */ }  // Virtual destructor
};

3. Returning Dangling References

Problem:

const std::string& getName() {
    std::string name = "temp";
    return name;  // Returns reference to destroyed object!
}

Fix:

std::string getName() {
    return "temp";  // Return by value (move semantics)
}

// Or if truly returning member:
const std::string& getName() const {
    return memberName;  // OK - member outlives function
}

4. Iterator Invalidation

Problem:

std::vector<int> vec = {1, 2, 3, 4, 5};
for (auto it = vec.begin(); it != vec.end(); ++it) {
    if (*it == 3) {
        vec.erase(it);  // it is now invalid!
    }
}

Fix:

for (auto it = vec.begin(); it != vec.end();) {
    if (*it == 3) {
        it = vec.erase(it);  // erase returns next valid iterator
    } else {
        ++it;
    }
}

// Or use erase-remove idiom
vec.erase(std::remove(vec.begin(), vec.end(), 3), vec.end());

5. Copying Large Objects Unnecessarily

Problem:

std::vector<int> getData() {
    std::vector<int> data(1000000);
    // fill data
    return data;  // Looks like copy but OK (NRVO)
}

void process(std::vector<int> data) {  // Copy!
    // Use data
}

Fix:

// Return by value is OK (move semantics / NRVO)
std::vector<int> getData() {
    std::vector<int> data(1000000);
    return data;  // Moved or elided
}

// Take by const reference if not modifying
void process(const std::vector<int>& data) {
    // Use data
}

// Take by rvalue reference if consuming
void process(std::vector<int>&& data) {
    myData = std::move(data);
}

6. String Null-Termination Confusion

Problem:

// Java strings are not null-terminated
// C++ std::string is, but C-style strings require care

char buffer[10];
std::string str = "0123456789";  // 10 chars
strcpy(buffer, str.c_str());  // Buffer overflow! Need 11 bytes for \0

Fix:

char buffer[11];  // One extra for null terminator
std::strncpy(buffer, str.c_str(), sizeof(buffer) - 1);
buffer[sizeof(buffer) - 1] = '\0';  // Ensure null termination

// Or better: just use std::string
std::string buffer = str;

7. Unsigned Integer Underflow

Problem:

// Java doesn't have unsigned types (except char)
// C++ does, and they can underflow

size_t count = 0;
count--;  // Underflows to SIZE_MAX (very large number)!

for (size_t i = vec.size() - 1; i >= 0; --i) {  // Infinite loop!
    // Process vec[i]
}

Fix:

// Use signed for arithmetic that can go negative
int count = 0;
count--;  // -1

// Reverse iteration
for (size_t i = vec.size(); i-- > 0;) {
    // Process vec[i]
}

// Or use reverse iterators
for (auto it = vec.rbegin(); it != vec.rend(); ++it) {
    // Process *it
}

8. Const Correctness

Problem:

// Java doesn't enforce const, C++ does

class Data {
    std::string value;
public:
    std::string getValue() {  // Not const!
        return value;
    }
};

void print(const Data& data) {
    std::cout << data.getValue();  // Error: calling non-const method on const object
}

Fix:

class Data {
    std::string value;
public:
    const std::string& getValue() const {  // Const method
        return value;
    }
};

---

Tooling

Tool	Purpose	Notes
CMake	Build system	De facto standard
vcpkg	Package manager	Microsoft's package manager
Conan	Package manager	Decentralized, flexible
Google Test	Testing framework	Most popular
Catch2	Testing framework	Header-only, BDD style
Google Mock	Mocking framework	Works with Google Test
Clang-Format	Code formatter	Based on LLVM
Clang-Tidy	Static analyzer	Catches common errors
Valgrind	Memory debugger	Detects leaks, errors
AddressSanitizer	Memory error detector	Part of Clang/GCC
Doxygen	Documentation	Javadoc equivalent

---

Examples

Example 1: Simple - User Class

Java:

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + "}";
    }
}

C++:

#include <string>
#include <sstream>

class User {
private:
    std::string name;
    int age;

public:
    User(std::string name, int age)
        : name(std::move(name)), age(age) {}

    const std::string& getName() const {
        return name;
    }

    int getAge() const {
        return age;
    }

    std::string toString() const {
        std::ostringstream oss;
        oss << "User{name='" << name << "', age=" << age << "}";
        return oss.str();
    }
};

Example 2: Medium - Repository Pattern

Java:

public interface UserRepository {
    Optional<User> findById(Long id);
    List<User> findAll();
    void save(User user);
    void delete(Long id);
}

public class InMemoryUserRepository implements UserRepository {
    private Map<Long, User> users = new HashMap<>();

    @Override
    public Optional<User> findById(Long id) {
        return Optional.ofNullable(users.get(id));
    }

    @Override
    public List<User> findAll() {
        return new ArrayList<>(users.values());
    }

    @Override
    public void save(User user) {
        users.put(user.getId(), user);
    }

    @Override
    public void delete(Long id) {
        users.remove(id);
    }
}

C++:

#include <unordered_map>
#include <vector>
#include <optional>
#include <memory>

class UserRepository {
public:
    virtual ~UserRepository() = default;

    virtual std::optional<User> findById(int64_t id) = 0;
    virtual std::vector<User> findAll() = 0;
    virtual void save(const User& user) = 0;
    virtual void remove(int64_t id) = 0;
};

class InMemoryUserRepository : public UserRepository {
private:
    std::unordered_map<int64_t, User> users;

public:
    std::optional<User> findById(int64_t id) override {
        auto it = users.find(id);
        if (it != users.end()) {
            return it->second;
        }
        return std::nullopt;
    }

    std::vector<User> findAll() override {
        std::vector<User> result;
        result.reserve(users.size());
        for (const auto& [_, user] : users) {
            result.push_back(user);
        }
        return result;
    }

    void save(const User& user) override {
        users[user.getId()] = user;
    }

    void remove(int64_t id) override {
        users.erase(id);
    }
};

Example 3: Complex - Service with Dependencies

Java:

public class UserService {
    private final UserRepository repository;
    private final EmailService emailService;
    private final Logger logger;

    public UserService(UserRepository repository,
                      EmailService emailService) {
        this.repository = repository;
        this.emailService = emailService;
        this.logger = LoggerFactory.getLogger(UserService.class);
    }

    public User createUser(String name, String email, int age) {
        logger.info("Creating user: {}", name);

        if (name == null || name.isEmpty()) {
            throw new IllegalArgumentException("Name cannot be empty");
        }

        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("Invalid age: " + age);
        }

        User user = new User(name, email, age);
        repository.save(user);

        try {
            emailService.sendWelcomeEmail(user);
        } catch (EmailException e) {
            logger.warn("Failed to send welcome email", e);
        }

        return user;
    }

    public List<User> getActiveUsers() {
        return repository.findAll().stream()
            .filter(User::isActive)
            .sorted(Comparator.comparing(User::getName))
            .collect(Collectors.toList());
    }

    public Optional<User> updateUserAge(Long id, int newAge) {
        Optional<User> userOpt = repository.findById(id);

        if (userOpt.isPresent()) {
            User user = userOpt.get();
            user.setAge(newAge);
            repository.save(user);
            logger.info("Updated user {} age to {}", id, newAge);
        }

        return userOpt;
    }
}

C++:

#include <memory>
#include <string>
#include <vector>
#include <optional>
#include <algorithm>
#include <spdlog/spdlog.h>  // Popular logging library

class UserService {
private:
    std::shared_ptr<UserRepository> repository;
    std::shared_ptr<EmailService> emailService;
    std::shared_ptr<spdlog::logger> logger;

public:
    UserService(std::shared_ptr<UserRepository> repository,
                std::shared_ptr<EmailService> emailService)
        : repository(std::move(repository))
        , emailService(std::move(emailService))
        , logger(spdlog::get("UserService")) {
        if (!logger) {
            logger = spdlog::stdout_color_mt("UserService");
        }
    }

    User createUser(const std::string& name, const std::string& email, int age) {
        logger->info("Creating user: {}", name);

        if (name.empty()) {
            throw std::invalid_argument("Name cannot be empty");
        }

        if (age < 0 || age > 150) {
            throw std::invalid_argument("Invalid age: " + std::to_string(age));
        }

        User user(name, email, age);
        repository->save(user);

        try {
            emailService->sendWelcomeEmail(user);
        } catch (const EmailException& e) {
            logger->warn("Failed to send welcome email: {}", e.what());
        }

        return user;
    }

    std::vector<User> getActiveUsers() {
        auto users = repository->findAll();

        // Filter active users
        std::vector<User> active;
        std::copy_if(users.begin(), users.end(), std::back_inserter(active),
            [](const User& u) { return u.isActive(); });

        // Sort by name
        std::sort(active.begin(), active.end(),
            [](const User& a, const User& b) {
                return a.getName() < b.getName();
            });

        return active;
    }

    // Or with C++20 ranges
    std::vector<User> getActiveUsersRanges() {
        auto users = repository->findAll();

        auto active = users
            | std::views::filter([](const User& u) { return u.isActive(); })
            | std::ranges::to<std::vector>();

        std::ranges::sort(active, {}, &User::getName);

        return active;
    }

    std::optional<User> updateUserAge(int64_t id, int newAge) {
        auto userOpt = repository->findById(id);

        if (userOpt.has_value()) {
            User& user = *userOpt;
            user.setAge(newAge);
            repository->save(user);
            logger->info("Updated user {} age to {}", id, newAge);
        }

        return userOpt;
    }
};

---

See Also

For more examples and patterns, see:

• meta-convert-dev - Foundational patterns with cross-language examples
• convert-golang-rust - Similar systems language conversion patterns
• lang-java-dev - Java development patterns
• lang-cpp-dev - C++ development patterns

Cross-cutting pattern skills:

• patterns-concurrency-dev - Threading, mutexes, async patterns
• patterns-serialization-dev - JSON, data validation across languages
• patterns-metaprogramming-dev - Templates, generics, annotations