Forum Pasja Informatyki - Najnowsze z tagiem c-plus-plus

Jak ulepszyć kod gry RPG?

Tue, 19 May 2026 15:24:43 +0000

Cześć jak można ulepszyć kod tej tekstowej gry rpg w stylu Diablo, Path of Exile.

Enemy.cpp

#include "Enemy.h"

void Enemy::createEnemy(int type)
{
    if (type == 0) {
        name = "Zombie";
        maxHealth = 50;
        damage = 5;
    } else if (type == 1) {
        name = "Szkieletor";
        maxHealth = 35;
        damage = 8;
    } else if (type == 2) {
        name = "Goblinek";
        maxHealth = 30;
        damage = 10;
    } else {
        name = "Zombiak";
        maxHealth = 50;
        damage = 5;
    }
    currentHealth = maxHealth;
}

void Enemy::SetLevel(int enemyLevel)
{
    level = enemyLevel;
    maxHealth += (level - 1) * 10;
    damage += (level - 1) * 2;
    currentHealth = maxHealth;
}

Enemy.h

#pragma once
#include <string>

class Enemy {
public:
    std::string name { }; // nowa składnia C++23
    int maxHealth { 0 };
    int currentHealth { 0 };
    int level { 1 };
    int damage { 0 };

    void createEnemy(int type);
    void SetLevel(int enemyLevel);
};

main.cpp

#include "Enemy.h"
#include "Player.h"
#include "Print.h"
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <vector>

// Stany gry
enum class GameState { MainMenu,
    CharacterSelect,
    Playing,
    Exit };

// Funkcje losujące przeciwników
int GetEnemyCount()
{
    int roll = rand() % 100;
    if (roll < 50)
        return 1;
    if (roll < 75)
        return 2;
    if (roll < 90)
        return 3;
    return 4;
}

int GetEnemyType() { return rand() % 3; } // 0-Zombie,1-Szkieletor,2-Goblin
int GetEnemyLevel() { return 1 + rand() % 3; }

// Funkcja losująca obrażenia z możliwością krytyka
int DealDamage(int baseDamage)
{
    int roll = rand() % 100;
    if (roll < 10)
        return baseDamage * 2; // 10% krytyk
    return baseDamage;
}

int main()
{
    srand(time(0));

    Player player;
    bool running = true;
    GameState state = GameState::MainMenu;

    while (running) {
        if (state == GameState::MainMenu) {
            Print::WriteColor("====UpiornePotyczki====\n\n", Color::Red);
            Print::Write("1. Nowa Gra\n");
            Print::Write("2. Wyjście\n");
            Print::WriteColor("\nWybierz opcję: ", Color::Yellow);
            int choice;
            std::cin >> choice;

            if (choice == 1)
                state = GameState::CharacterSelect;
            else if (choice == 2)
                state = GameState::Exit;
            Print::Clear();
        }

        else if (state == GameState::CharacterSelect) {
            Print::WriteColor("Wybierz klasę postaci:\n\n", Color::Yellow);
            Print::Write("1. Wojownik\n");
            Print::Write("2. Łotrzyk\n");
            Print::Write("3. Mag\n");
            Print::WriteColor("\nOpcja: ", Color::Yellow);

            int choice;
            std::cin >> choice;
            player.SetClass(choice);
            player.DisplayPickedCharacter();

            int continueChoice;
            std::cin >> continueChoice;
            Print::Clear();
            state = GameState::Playing;
        }

        else if (state == GameState::Playing) {
            std::vector<Enemy> enemies;
            int enemyCount = GetEnemyCount();

            for (int i = 0; i < enemyCount; i++) {
                Enemy enemy;
                enemy.createEnemy(GetEnemyType());
                enemy.SetLevel(GetEnemyLevel());
                enemies.push_back(enemy);
            }

            bool inCombat = true;
            while (inCombat) {
                Print::Clear();
                Print::WriteColor("Pojawiają się przeciwnicy!\n\n", Color::Red);

                Print::Write("Twoje zdrowie:\n");
                Print::DrawHPBar(player.currentHealth, player.maxHealth, 20, Color::Green);

                for (size_t i = 0; i < enemies.size(); i++) {
                    Print::Write(enemies[i].name + " (Poziom " + std::to_string(enemies[i].level) + "):\n");
                    Color hpColor = enemies[i].currentHealth > 0 ? Color::Yellow : Color::Red;
                    Print::DrawHPBar(enemies[i].currentHealth, enemies[i].maxHealth, 20, hpColor);
                }

                Print::Write("\n1. Atak\n2. Ucieczka\n");
                Print::WriteColor("Opcja: ", Color::Yellow);
                int choice;
                std::cin >> choice;

                if (choice == 1) {
                    Print::WriteColor("\nWybierz przeciwnika do ataku: ", Color::Yellow);
                    int targetChoice;
                    std::cin >> targetChoice;
                    size_t targetIndex = targetChoice - 1;

                    if (targetIndex < enemies.size()) {
                        int dmg = DealDamage(player.damage);
                        enemies[targetIndex].currentHealth -= dmg;

                        Print::Write("\nUderzasz ");
                        Print::WriteColor(enemies[targetIndex].name, Color::Yellow);
                        if (dmg > player.damage)
                            Print::WriteColor(" krytycznie! ", Color::Red);
                        Print::Write(" za " + std::to_string(dmg) + " obrażeń!\n");

                        if (enemies[targetIndex].currentHealth <= 0) {
                            enemies[targetIndex].currentHealth = 0;
                            Print::WriteColor("\n" + enemies[targetIndex].name + " został pokonany!\n", Color::Green);
                            enemies.erase(enemies.begin() + targetIndex);
                        }

                        if (enemies.empty()) {
                            Print::WriteColor("\nWygrałeś walkę!\n", Color::Green);
                            inCombat = false;
                        } else {
                            Print::Write("\nPrzeciwnicy atakują!\n");
                            for (size_t i = 0; i < enemies.size(); i++) {
                                int enemyDmg = DealDamage(enemies[i].damage);
                                player.currentHealth -= enemyDmg;
                                if (player.currentHealth < 0)
                                    player.currentHealth = 0;

                                Print::WriteColor(enemies[i].name, Color::Red);
                                Print::Write(" uderza cię za " + std::to_string(enemyDmg) + " obrażeń!\n");

                                if (player.currentHealth <= 0) {
                                    Print::WriteColor("\nZostałeś pokonany..\n", Color::Red);
                                    inCombat = false;
                                    state = GameState::Exit;
                                    break;
                                }
                            }
                        }
                    } else {
                        Print::Write("\nNieprawidłowy cel!\n");
                    }
                } else if (choice == 2) {
                    Print::WriteColor("\nUciekasz jak tchórz!\n", Color::Yellow);
                    inCombat = false;
                } else {
                    Print::Write("\nNieprawidłowy wybór!\n");
                }

                Print::WriteColor("\nNaciśnij Enter, aby kontynuować...", Color::Cyan);
                std::cin.ignore();
                std::cin.get();
            }

            state = GameState::Exit;
        }

        else if (state == GameState::Exit) {
            running = false;
        }
    }

    Print::WriteColor("\n************************************\n", Color::Magenta);
    Print::WriteColor("* Dzięki za grę w UpiornePotyczki! *\n", Color::Magenta);
    Print::WriteColor("************************************\n", Color::Magenta);

    return 0;
}

Player.cpp

#include "Player.h"
#include "Print.h"

void Player::SetClass(int choice)
{
    name = "Bohater";
    if (choice == 1) {
        playerClass = "Wojownik";
        strength = 10;
        intelligence = 2;
        vitality = 8;
    } else if (choice == 2) {
        playerClass = "Łotrzyk";
        strength = 6;
        intelligence = 5;
        vitality = 6;
    } else if (choice == 3) {
        playerClass = "Mag";
        strength = 2;
        intelligence = 10;
        vitality = 5;
    }
    CalculateStats();
}

void Player::CalculateStats()
{
    maxHealth = 50 + vitality * 10;
    currentHealth = maxHealth;
    maxMana = 30 + intelligence * 10;
    currentMana = maxMana;

    if (playerClass == "Wojownik")
        damage = strength * 2;
    else if (playerClass == "Łotrzyk")
        damage = strength * 2 + 2;
    else if (playerClass == "Mag")
        damage = intelligence * 2;
    else
        damage = 5;
}

void Player::DisplayPickedCharacter()
{
    Print::Clear();
    Print::Write("Wybrałeś ");
    Print::WriteColor(playerClass, Color::Cyan);
    Print::Write("!\n\n");
    Print::Write("Siła: " + std::to_string(strength) + "\n");
    Print::Write("Inteligencja: " + std::to_string(intelligence) + "\n");
    Print::Write("Witalność: " + std::to_string(vitality) + "\n");
    Print::Write("Zdrowie: ");
    Print::WriteColor(std::to_string(currentHealth), Color::Green);
    Print::Write("\nMana: ");
    Print::WriteColor(std::to_string(currentMana), Color::Cyan);
    Print::Write("\n\nNaciśnij 1, aby kontynuować: ");
}

Player.h

#pragma once
#include <string>

class Player {
public:
    std::string name { }; // nowa składnia C++23
    std::string playerClass { };

    int strength { 0 };
    int intelligence { 0 };
    int vitality { 0 };

    int maxHealth { 0 };
    int currentHealth { 0 };

    int maxMana { 0 };
    int currentMana { 0 };

    int damage { 0 };

    void SetClass(int choice);
    void CalculateStats();
    void DisplayPickedCharacter();
};

Print.cpp

#include "Print.h"
#include <cstdlib>

void Print::Write(const std::string& text) { std::print("{}", text); }

void Print::SetColor(Color color)
{
    switch (color) {
    case Color::Red:
        std::print("\033[31m");
        break;
    case Color::Green:
        std::print("\033[32m");
        break;
    case Color::Yellow:
        std::print("\033[33m");
        break;
    case Color::Cyan:
        std::print("\033[36m");
        break;
    case Color::Blue:
        std::print("\033[34m");
        break;
    case Color::Magenta:
        std::print("\033[35m");
        break;
    case Color::White:
        std::print("\033[37m");
        break;
    case Color::Black:
        std::print("\033[30m");
        break;
    default:
        std::print("\033[0m");
        break;
    }
}

void Print::WriteColor(const std::string& text, Color color)
{
    SetColor(color);
    std::print("{}", text);
    SetColor(Color::Default);
}

void Print::Clear() { system("clear"); }

void Print::DrawHPBar(int current, int max, int width, Color color)
{
    int filled = (current * width) / max;
    SetColor(color);
    std::print("[");
    for (int i = 0; i < filled; i++)
        std::print("█");
    for (int i = filled; i < width; i++)
        std::print(" ");
    std::print("] {}/{}\n", current, max);
    SetColor(Color::Default);
}

Print.h

#pragma once
#include <print>

enum class Color { Default,
    Red,
    Green,
    Yellow,
    Cyan,
    Blue,
    Magenta,
    White,
    Black };

class Print {
public:
    static void Write(const std::string& text);
    static void SetColor(Color color);
    static void WriteColor(const std::string& text, Color color);
    static void Clear();
    static void DrawHPBar(int current, int max, int width, Color color);
};

Makefile

# Kompilator i flagi
CXX = clang++
CXXFLAGS = -std=c++23 -Wall -Wextra -I./src

# Katalogi
SRC_DIR = src
BIN_DIR = bin

# Pliki źródłowe
SRCS = $(SRC_DIR)/main.cpp \
       $(SRC_DIR)/Player.cpp \
       $(SRC_DIR)/Enemy.cpp \
       $(SRC_DIR)/Print.cpp

# Plik wynikowy
TARGET = $(BIN_DIR)/UpiornePotyczki

# Domyślna akcja
all: $(TARGET)

# Kompilacja plików źródłowych i linkowanie
$(TARGET): $(SRCS)
	@mkdir -p $(BIN_DIR)
	$(CXX) $(CXXFLAGS) $^ -o $@

# Czyszczenie plików obiektowych i binarnych
clean:
	rm -rf $(BIN_DIR)/*.o $(TARGET)

CMakeLists.txt

cmake_minimum_required(VERSION 4.3.1)
project(UpiornePotyczki)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED True)

# Dodajemy wszystkie pliki źródłowe
file(GLOB SOURCES "src/*.cpp")

add_executable(UpiornePotyczki ${SOURCES})

README.md

# UpiornePotyczki

Konsolowa gra RPG w C++.

## Funkcje
- Wybór klasy: Wojownik, Łotrzyk, Mag
- Walki z losowymi przeciwnikami (Zombie, Szkieletor, Goblin)
- Paski HP w konsoli, kolory i komunikaty o krytykach
- System poziomów przeciwników i skalowanie obrażeń

## Kompilacja i uruchamianie

### Wymagania
- Kompilator C++23 (np. `clang++` lub `g++` obsługujący C++23)
- Użyłem Clang 22.1.5
- System Linux lub Mac (komenda `system("clear")` używana do czyszczenia konsoli)

### Kompilacja za pomocą Makefile

1. Przejdź do katalogu projektu:
   ```bash
   cd /ścieżka/do/project

## Kompilacja
```bash
mkdir build
cd build
cmake ..
make
./bin/UpiornePotyczki

Możesz też na szybko skompilować za pomocą polecenia w rozszerzeniu VSCode o nazwie Code Runner.

"code-runner.executorMap": {
  "cpp": "clear && cd $dir && mkdir -p bin && cd bin && clang++ -std=c++23 ../Player.cpp ../Enemy.cpp ../Print.cpp ../$fileName -o $fileNameWithoutExt && ./$fileNameWithoutExt",
}

Czy ktoś chciał by przetestować moją gre

Sun, 26 Apr 2026 11:55:34 +0000

Cześć wszystkim!

Chciałbym zaprezentować Wam mój projekt, nad którym obecnie pracuję. Gra jest w fazie rozwoju, ale podstawowe mechaniki są już zaimplementowane. Zależy mi na Waszych opiniach, wyłapaniu ewentualnych błędów oraz sugestiach, co mógłbym dodać w przyszłości.

Minecoz (Pre-classic)

Mój najnowszy projekt pisany w C++ przy użyciu biblioteki SDL3. Skupiłem się tutaj na wydajności i nieskończonym świecie.

Co już działa:

Nieskończona mapa.
Dynamiczny generator drzew.
Kamera podążająca za graczem.
System animacji postaci.

Link do pobrania: Pobierz Minecoz

Gdy kopiuje pętle4 z folderu kurs_cpp_odc3 gdzie indziej - Unable to start debugging

Sun, 15 Feb 2026 12:10:24 +0000

Cześć Gdy kopiuje pętle4 z folderu kurs_cpp_odc3 gdzie indziej. Przy debugowanie pojawia się komunikat: Unable to start debugging. Unexpected GDB output from command"-environment-cd "C:\\Users\\...\imię" "C:Users\\...imię No such file or directory

Gdy uruchamiam sam plik z folderu kurs_cpp_odc3 błąd nie występuje. Gdy podaję ścieżke do folderu program uruchamia się. Używam Visual Studio Code Windows 11 Home x64

Nie mogę zrobić programu JEBUT z kursu pasja informatyki C++

Sat, 14 Feb 2026 15:51:17 +0000

Hej robię programik z tego poradnika:

https://www.youtube.com/watchv=y6GOYVTVvqo&list=PLOYHgt8dIdoxx0Y5wzs7CFpmBzb40PaDo&index=4

Nie działa System ("cls") w Visual Studio Code. W terminalu Windowsowym działa a w Visual Studio Code nie działa dlaczego?

Używam Windows 11 Home x64.

#include <iostream>
#include <windows.h>
#include <stdlib.h>
#include <cstdlib>
#include <stdio.h>
#include <conio.h>

using namespace std;


int main()
{
    for (int i=15; i>=0; i--)
    {
    
    Sleep(1000);
    system ("cls");

    cout << i << endl;
    }
    cout << "JEBUT";

    return 0;
}

Offtop parametry funkcji

Fri, 19 Dec 2025 22:01:22 +0000

Nakładka na C, coraz bardziej się rozbudowuje ;)

struct LabelOptions {
    int fontSize = 12;
    std::string anchor = "middle";
    std::string color = "black";
};

void addLabel(int x, int y, const std::string& text, const LabelOptions& opts = {}) {
    std::cout << "x=" << x << " y=" << y << " text=" << text
              << " fontSize=" << opts.fontSize
              << " anchor=" << opts.anchor
              << " color=" << opts.color << "\n";
}

addLabel(100, 200, "Hello"); // używa domyślnych wartości
addLabel(100, 200, "Hello", {16, "end", "red"}); // nadpisuje wszystkie
addLabel(100, 200, "Hello", {.anchor="end"});    // C++20: designated initializers

Normalnie wyścig zbrojeń z JS. Wiem, wiem język to biblioteki, a nie podstawowa składania. Ale już niekonieczna jest przemyślana kolejność argumentów.

Wiszące referencje w C++

Wed, 23 Apr 2025 06:10:57 +0000

Ma ktoś pomyśł jak naprawić problem wiszących referencji w metodzie `menu::add_submenu`? Jak w ogóle poprawić można mój kod?

main.cpp

// the purpose of the below code is to test menu class

#include "menu.h"
#include <cstdlib>
#include <iostream>

int main() {
    std::cin.exceptions(std::cin.eofbit);
    try {
        pt::menu main_menu{"Main menu"};
        main_menu.add_item("item 1",
                           []() { std::cout << "item 1" << std::endl; });
        main_menu.add_item("item 2",
                           []() { std::cout << "item 2" << std::endl; });
        {
            pt::menu submenu{"Submenu"};
            main_menu.add_submenu(submenu);
        }
        main_menu.loop();
    } catch (const std::exception& e) {
        std::cerr << e.what() << '\n';
        return EXIT_FAILURE;
    }
    std::cout << "Good bye!\n";
    return 0;
}

menu.h

#ifndef MENU_H_
#define MENU_H_

#include <functional>
#include <iosfwd>
#include <string>
#include <utility>
#include <vector>

namespace pt {

struct menu_item {
    menu_item(std::string title_val, std::function<void()> action_val);

    friend std::ostream& operator<<(std::ostream& lhs, const menu_item& rhs);

    std::string title{};
    std::function<void()> action{};
};

class menu {
 public:
    explicit menu(std::string title_val, std::string description_val = "",
                  std::vector<menu_item> items_val = {});

    void add_item(menu_item item);
    void add_item(std::string title_val, std::function<void()> action);
    void add_item_at(int index, menu_item item);
    void add_item_at(int index, std::string title_val,
                     std::function<void()> action);
    void remove_item(int index);

    void add_submenu(menu menu_val);
    void add_submenu(std::string title_val, menu menu_val);
    void add_submenu_at(int index, menu menu_val);
    void add_submenu_at(int index, std::string title_val, menu menu_val);

    void set_title(std::string title_val);
    void set_description(std::string description_val);

    void loop() const;

 private:
    // helper functions
    void print_choices() const;
    char read_choice() const;
    void check_index(std::size_t index) const;
    void print_title(std::string_view title) const;

    // wrapper function for menu::loop
    std::function<void()> invoke_menu_loop(const menu& menu_val);

    static constexpr char quit_choice = 'q';
    static int nesting_level;
    std::string title{};
    std::string description{};
    std::vector<menu_item> items{};
};

}  // namespace pt

#endif  // MENU_H_

menu.cpp

#include "menu.h"
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

namespace pt {

// menu_item constructors
menu_item::menu_item(std::string title_val, std::function<void()> action_val)
    : title{std::move(title_val)}, action{std::move(action_val)} {}

// menu_item struct i/o operators
std::ostream& operator<<(std::ostream& lhs, const menu_item& rhs) {
    return lhs << rhs.title;
}

// menu class constructors
menu::menu(std::string title_val, std::string description_val,
           std::vector<menu_item> items_val)
    : title{std::move(title_val)}, description{std::move(description_val)},
      items{std::move(items_val)} {}

// menu class static variables
int menu::nesting_level{0};

// menu class public interface
void menu::add_item(menu_item item) { items.push_back(std::move(item)); }

void menu::add_item(std::string title_val, std::function<void()> action_val) {
    items.emplace_back(std::move(title_val), std::move(action_val));
}

void menu::add_item_at(int index, menu_item item) {
    check_index(index);
    items.insert(items.begin() + index, std::move(item));
}

void menu::add_item_at(int index, std::string title_val,
                       std::function<void()> action) {
    check_index(index);
    items.emplace(items.begin() + index, std::move(title_val),
                  std::move(action));
}

void menu::remove_item(int index) {
    check_index(index);
    items.erase(items.begin() + index);
}

void menu::add_submenu(menu menu_val) {
    items.emplace_back(menu_val.title, invoke_menu_loop(menu_val));
}

void menu::add_submenu(std::string title_val, menu menu_val) {
    items.emplace_back(title_val, invoke_menu_loop(menu_val));
}

void menu::add_submenu_at(int index, menu menu_val) {
    check_index(index);
    items.insert(items.begin() + index,
                 menu_item{menu_val.title, invoke_menu_loop(menu_val)});
}

void menu::add_submenu_at(int index, std::string title_val, menu menu_val) {
    check_index(index);
    items.insert(items.begin() + index,
                 menu_item{title_val, invoke_menu_loop(menu_val)});
}

void menu::set_title(std::string title_val) { title = std::move(title_val); }

void menu::set_description(std::string description_val) {
    description = std::move(description_val);
}

void menu::loop() const {
    bool active{true};
    ++nesting_level;
    while (active) {
        print_title(title);
        if (!description.empty()) {
            std::cout << std::endl;
            std::cout << description;
            std::cout << std::endl;
        }
        char choice{read_choice()};
        if (choice == quit_choice) {
            --nesting_level;
            active = false;
        } else {
            std::cout << '\n';
            std::size_t index{static_cast<std::size_t>(choice) - '0'};
            if (index > items.size()) {
                std::cout << "Invalid choice!\n";
                continue;
            }
            // call function bound to menu item
            items[choice - '1'].action();
            // wait until user press the enter key
            std::cout << "\nPress enter to continue..." << std::endl;
            std::string line;
            std::getline(std::cin, line);
        }
    }
}

// menu class private functions
void menu::print_choices() const {
    for (std::size_t i = 0; i < items.size(); ++i) {
        std::cout << i + 1 << ") " << items[i] << '\n';
    }
    std::cout << "q) " << (nesting_level > 1 ? "Back" : "Quit");
    std::cout << std::endl;
}

char menu::read_choice() const {
    std::string user_input;
    char choice;
    bool valid{false};

    std::cout << "What do you want to do?\n";
    do {
        print_choices();
        std::cout << "Your choice: ";
        std::getline(std::cin, user_input);
        if (user_input.length() > 1 || user_input.empty()) {
            std::cout << "Please enter the valid choice.\n";
            continue;
        }
        choice = tolower(user_input.at(0));
        if ((choice - '1') < 0 ||
            (static_cast<std::size_t>(choice - '1') >= items.size() &&
             (choice != quit_choice))) {
            std::cout << "Invalid choice!\n";
        } else {
            valid = true;
        }
    } while (!valid);
    return choice;
}

void menu::check_index(std::size_t index) const {
    const std::size_t max_allowed_idx{items.size() - 1};
    if (index > max_allowed_idx) {
        std::ostringstream oss;
        oss << "index value must be between " << index << " and "
            << max_allowed_idx;
        throw std::out_of_range{oss.str()};
    }
}

void menu::print_title(std::string_view title) const {
    std::size_t title_len = title.size();
    std::size_t width = title_len + 4;
    for (std::size_t i = 0; i < width; ++i) {
        std::cout << "*";
    }
    std::cout << "\n* " << title << " *\n";
    for (std::size_t i = 0; i < width; ++i) {
        std::cout << "*";
    }
    std::cout << std::endl;
}

// wrapper function for menu::loop
std::function<void()> menu::invoke_menu_loop(const menu& the_menu) {
    return [&the_menu]() { the_menu.loop(); };
}

}  // namespace pt

Struktura projektu w C++

Wed, 23 Apr 2025 05:34:30 +0000

Potrzebuję wskazówek jak ogarnąć strukturę większych programów, w sensie podział na pliki nagłówków, testy, źródełka, dokumentację itd. Macie jakieś sensowne sprawdzone sposoby na to? Pytanie kieruję do osób, które mają już trochę doświadczenia z C++

Pytam bo mi się zaczął programik rozrastać i trzymanie wszystkiego w jednym katalogu z Makefile, CPPLINT.cfg itd. jest mało praktyczne

Wskaźniki NULL w C i C++

Sat, 12 Apr 2025 18:02:43 +0000

Czytam https://stackoverflow.com/questions/1296843/what-is-the-difference-between-null-0-and-0 i nadal nie potrafię zrozumieć dlaczego poniższe fragmenty kodu są nieprawidłowe

// 1
int mojnull = 0;
int* wsk = funkcja_ktora_moze_zwrocic_wsk_null();
if (wsk == mojnull) {
    std::cerr << "Wystapil blad!\n";
    std::abort();
}
// 2 - na platformie gdzie wskaznik null jest reprezentowany przez 0xDEADBEEF
#define MYNULL 0xDEADBEEF
int* wsk = funkcja_ktora_moze_zwrocic_wsk_null();
if (wsk == MYNULL) {
    std::cerr << "Wystapil blad!\n";
    std::abort();
}

Wyjaśni mi ktoś łopatologicznie?

Przecież wskaźnik to zmienna przechowująca adres pamięci a w 1 adresem tym jest zero i mojnull też ma wartość zero, więc obie zmienne to obiekty przechowujące wartość zero tylko innego typu.

W 2 wskaźnik pusty jest reprezentowany przez 0xDEADBEEF na nietypowej platformie, za MYNULL po przetworzeniu przez preprocesor jest podstawiane 0xDEADBEEF i jest to porównywane z wartością zmiennej wsk a 0xDEADBEEF jest przecież wartością reprezentującą wskaźnik pusty na tejże platformie. Więc 0 to chyba powinien być konstrukt synktatyczny, który odpowiada 0xDEADBEEF.

Czy opierać stosy, kolejki na istniejącej strukturze danych czy napisać całkowicie od zera?

Sat, 12 Apr 2025 15:53:49 +0000

Jak w temacie, lepiej oprzeć na array liście i wywoływać odpowiednie metody, czy całkowicie napisać od zera to co potrzebne do implementacji ADT?

Semantyka przenoszenia w C++ - trzy pytania

Thu, 27 Mar 2025 19:09:19 +0000

Hej,

Dlaczego w przypadku używania std::move nie tworzy się osobnych konstruktorów tak jak pokazano to w // 1 i w // 2 tylko zwyczajnie używa się przekazywania przez wartość?

Przypadek // 1 w którym przekazujemy zwykłe l-wartości jestem w stanie zrozumieć, wtedy po prostu konwertujemy f i l za pomocą std::move na r-wartości i wywołujemy odpowiednie konstruktory przenoszące odpowiadających im klas skoro mamy r-wartości (std::move dokonuje konwersji przekazanego mu argumentu na r-wartość żeby można było go przenieść).

Nie rozumiem natomiast tego czemu nie tworzymy analogicznej funkcji jak pokazano w // 2 przyjmującej referencje do r-wartości. Przecież przekazując przez wartość std::string("Andrzej") do konstruktora // 1 skoro mamy przekazywanie przez wartość a nie referencję to i tak dokonywana jest kopia tego obiektu. Konkretnie tworzona jest obiekt tymczasowy i to co jest w tym obiekcie jest przenoszone do firstname i lastname. Gdyby użyć referencji do r-wartości to nie byłoby tworzonego żadnego obiektu tymczasowego.

Drugie moje pytanie dotyczy czy dobrze rozumiem dlaczego w kodzie załączonym do tego pytania mamy na wyjściu , , 12. Według mnie wyjście jest takie ponieważ w przypadku std::string zostały przeniesione zasoby powiązane z obiektem natomiast age nie otrzymał przypadkowej wartości dlatego że w tym przypadku age nie jest obiektem zarządzanym. Semantyka przenoszenia ma sens jedynie w odniesieniu do zasobów alokowanych dynamicznie przez new i delete lub w podobny sposób, zarządzanych przez instancje klas. W przypadku zwykłych intów czy floatów nie mamy odpowiedzialności za zwolnienie obiektu. Przeniesienie polega na transferze odpowiedzialności za zwolnienie zasobu. Ddobrze to rozumiem?

Trzecie pytanie dotyczy tego czy referencje do r-wartości wewnętrznie też są implementowane jako wskaźniki tak jak zwykłe l-wartościowe referencje.

Dziękuję i pozdrawiam,
whiteman808

~ ❯ cat main.cpp                                                                                                                                ✘ INT 19:30:01
#include <iostream>
#include <string>

class person {
public:
    person() : firstname{}, lastname{}, age{0} {}
    person(std::string f, std::string l, int a) // 1
        : firstname{std::move(f)}, lastname{std::move(l)}, age{a} {
        std::cout << f << ", " << l << ", " << a << '\n';
    }
    person(std::string&& f, std::string&& l, int a) // 2
        : firstname{std::move(f)}, lastname{std::move(l)}, age{a} {
        std::cout << f << ", " << l << ", " << a << '\n';
    }
    person(const person& p) { // konstruktor kopiujący
        firstname = p.firstname;
        lastname = p.lastname;
        age = p.age;
    }
private:
    std::string firstname;
    std::string lastname;
    int age;
};

int main() {
    person p{"Jan", "Kowalski", 12};
    return 0;
}
~ ❯ ./main                                                                                                                                            19:30:04
, , 12

Nazewnictwo obiektów w C i C++

Thu, 27 Mar 2025 19:07:12 +0000

Czy jest poprawne nazywanie obiektów typu `int x = 3` zasobami automatycznymi, podczas gdy `char* buffer = new char[BUF_SIZE];` zasobami zarządzanymi zamiast obiektami przechowywanymi na stosie i stercie?

Odpowiednik zmiennych statycznych w makrach C/C++

Tue, 25 Mar 2025 22:43:45 +0000

Jak zrobić odpowiednik zmiennych statycznych bez lączności w zwykłych funkcjach C++ przy użyciu makr preprocesora? Przepraszam za ciągłe wstawianie pytań dzisiaj ale dopiero poznaję C++

#include <iostream>

int test_successes = 0;
int test_failures = 0;

void test_assert(bool expr, std::string_view msg) {
    if (expr) {
        std::cout << "* test passed: " << msg << std::endl;
        ++test_successes;
    } else {
        std::cout << "* test failed: " << msg << std::endl;
        ++test_failures;
    }
}

void test_stats() {
    std::cout << "successes: " << test_successes << std::endl;
    std::cout << "failures: " << test_failures << std::endl;
}

int main() {
    test_assert(2 == 2, "2 == 2");
    test_assert(2 < 0 == false, "2 < 0 == false");
    test_assert(1 == 3, "1 == 3");
    test_stats();
    return 0;
}

Pokazywanie wyrażenia z kodu źródłowego w funkcjach inline

Tue, 25 Mar 2025 22:41:40 +0000

W jaki sposób mogę poniższe makra zamienić na funkcje inline, tak żeby pokazywały one wyrażenie podstawione za argument expr w kodzie źródłowym oprócz samego wyniku testu? W makrach jest to wykonalne ale wolę używać funkcji inline zamiast polegać na preprocesorze

#include <cassert>
#include <iostream>

#define CHECKPOINT(msg) (std::cerr << (msg) << std::endl)
#define ASSERT(expr) \
    assert((expr)); \
    CHECKPOINT("* test passed");
#define ASSERTM(msg, expr) \
    assert((void(msg), (expr))); \
    CHECKPOINT("* test passed");
#define ASSERT_FALSE(expr) \
    assert((expr) == false); \
    CHECKPOINT("* test passed");
#define ASSERTM_FALSE(msg, expr) \
    assert((void(msg), (expr) == false)); \
    CHECKPOINT("* test passed");
#define TEST_CASE(msg) \
    (std::cout << "TEST CASE: " << (msg) << std::endl)

Używanie w makrach preprocesora średników

Tue, 25 Mar 2025 22:38:12 +0000

Mam takie makro

#define CHECKPOINT(msg) (std::cerr << (msg) << std::endl)

Lepiej w definicjach makr dodawać średniki i wywoływać je np CHECKPOINT("test passed") czy nie robić średnika na końcu wyrażenia z std::cerr i w kodzie robić CHECKPOINT("test passed");?

Używanie jednocześnie wejścia/wyjścia z stdio.h i iostream

Tue, 25 Mar 2025 22:34:26 +0000

Czy można używać na przemian puts, fprintf, scanf i std::cout, std::cerr, std::cin w programie C++ bez ryzykowania pojawienia się nieoczekiwanych błędów w trakcie działania programu?

Generowanie kodu C i C++ w zależności od użytego kompilatora

Tue, 25 Mar 2025 22:20:59 +0000

Siemka

W jaki sposób mogę zrobić tak, by dla kodu kompilowanego gcc były używane inne funkcje itd. niż dla kodu kompilowanego g++?

Dziękuję i pozdrawiam

Pętle typu while(true) w programowaniu

Sat, 08 Mar 2025 16:42:48 +0000

Czy używanie nieskończonych pętli while (true), for (;;) to zła praktyka programistyczna? Pytam bo zastanawiam się nad przepisaniem kodu C++ w taki sposób by uniknąć niepotrzebnych deklaracji zmiennych i zrobić po prostu returna w odpowiednim ifie.

Program wpada w nieskończoną pętlę po naciśnięciu Ctrl+D

Fri, 07 Mar 2025 21:00:50 +0000

Gdy wciskam Ctrl+D program wpada w nieskończoną pętlę. Nie poskutowało std::cin.clear() i std::cin.ignore(std::numeric_limits<std::streamsize>::max(). Ma ktoś pomysł jak wyczyścić flagę eof w cin tak, aby po wciśnięciu Ctrl+D dalej był możliwy odczyt danych z konsoli?

unsigned int czy std::size_t?

Fri, 07 Mar 2025 15:36:16 +0000

Kiedy lepiej używać typu std::size_t a kiedy unsigned int? Tworzę klasę linked_list, a konkretnie metody insert i remove_at i mnie zastanawia czy lepiej w nich użyć size_t czy tego drugiego typu i dlaczego.

Interfejs menu w C++

Fri, 07 Mar 2025 15:31:51 +0000

Hej, napisałem interfejs menu w C++. Co sądzicie o moim programie, co mogę w nim poprawić? Czy jest coś do poprawy w kodzie źródłowym?

~/programy_cpp/linked_list ❯ cat main.cpp                                                                                                             17:30:52
// the purpose of the below code is to test menu class

#include <ios>
#include <iostream>
#include <limits>
#include <string>
#include <utility>
#include "menu.h"

/*
 * these functions are defined only to test menu.h library
 * i plan to merge these functions to the CalculatorApp class
 * in the future
 *
 * i wrote below code in a hurry
 */

// helper functions; will be moved into utils.h/utils.cpp in the future
inline void clear_console_input() {
    std::cin.clear();
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
}

double read_double(const std::string& prompt = "Enter the number: ") {
    double number;
    bool success{false};
    do {
        std::cout << prompt;
        if (std::cin >> number) {
            success = true;
        } else {
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            std::cout << "Error: not a number." << std::endl;
        }
    } while (!success);
    return number;
}

std::pair<double, double> read_operands() {
    double first{read_double("Enter the first operand: ")};
    double second{read_double("Enter the second operand: ")};
    clear_console_input();
    return std::make_pair(first, second);
}

std::pair<double, double> read_operands_div() {
    double first{read_double("Enter the first operand: ")};
    double second;
    while ((second = read_double("Enter the second operand: ")) == 0) {
        std::cout << "Error: number is equal to zero." << std::endl;
    }
    clear_console_input();
    return std::make_pair(first, second);
}

// calculator interface
void add() {
    auto numbers = read_operands();
    std::cout << "Result of " << numbers.first << " + " << numbers.second
              << " is " << numbers.first + numbers.second << std::endl;
}

void subtract() {
    auto numbers = read_operands();
    std::cout << "Result of " << numbers.first << " - " << numbers.second
              << " is " << numbers.first - numbers.second << std::endl;
}

void multiply() {
    auto numbers = read_operands();
    std::cout << "Result of " << numbers.first << " * " << numbers.second
              << " is " << numbers.first * numbers.second << std::endl;
}

void divide() {
    auto numbers = read_operands_div();
    std::cout << "Result of " << numbers.first << " / " << numbers.second
              << " is " << numbers.first / numbers.second << std::endl;
}

int main() {
    menu app{"Calculator"};
    app.add_item("Add", add);
    app.add_item("Subtract", subtract);
    app.add_item("Multiply", multiply);
    app.add_item("Divide", divide);
    menu menu2{"test"};
    app.add_submenu(menu2);
    app.loop();
    std::cout << "Good bye!\n";
    return 0;
}
~/programy_cpp/linked_list ❯ cat menu.h                                                                                                               17:30:55
#ifndef MENU_H
#define MENU_H

#include <functional>
#include <iostream>
#include <string>
#include <vector>

struct menu_item {
    explicit menu_item(const std::string& title_val) : title{title_val}, action{noop} {}
    menu_item(const std::string& title_val, std::function<void()> action_val)
        : title{title_val}, action{action_val} {}
    menu_item(const menu_item& item) : title{item.title}, action{item.action} {}

    friend std::ostream& operator<<(std::ostream& lhs, const menu_item& rhs);

    static void noop() { std::cout << "No action defined!\n"; }

    std::string title{};
    std::function<void()> action{};
};

class menu {
public:
    explicit menu(const std::string& title_val);
    menu(const std::string& title_val, const std::vector<menu_item>& items_val);
    menu(const std::string& title_val, const std::string& description_val);
    menu(const std::string& title_val, const std::string& description_val,
         const std::vector<menu_item>& items_val);

    void add_item(const menu_item& item);
    void add_item(const std::string& title_val, std::function<void()> action);
    void add_item_at(int index, const menu_item& item);
    void add_item_at(int index, const std::string& title_val,
                     std::function<void()> action);
    void remove_item(int index);

    void add_submenu(const menu& menu_val);
    void add_submenu(const std::string& title_val, const menu& menu_val);
    void add_submenu_at(int index, const menu& menu_val);
    void add_submenu_at(int index, const std::string& title_val,
                        const menu& menu_val);

    void set_title(const std::string& title_val);
    void set_description(const std::string& description_val);

    void loop() const;

private:
    // helper functions
    void print_choices() const;
    char read_choice() const;
    void check_index(std::size_t index) const;

    // wrapper function for menu::loop
    std::function<void()> invoke_menu_loop(const menu& menu_val);

    static int nesting_level;
    std::string title{};
    std::string description{};
    std::vector<menu_item> items{};
};

#endif // MENU_H
~/programy_cpp/linked_list ❯ cat menu.cpp                                                                                                             17:30:58
#include "menu.h"
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>

static constexpr char quit_choice = 'q';

// helper functions
static void print_title(const std::string& title) {
    std::size_t title_len = title.size();
    std::size_t width = title_len + 4;
    for (std::size_t i = 0; i < width; ++i) {
        std::cout << "*";
    }
    std::cout << "\n* " << title << " *\n";
    for (std::size_t i = 0; i < width; ++i) {
        std::cout << "*";
    }
    std::cout << std::endl;
}

// menu_item struct i/o operators
std::ostream& operator<<(std::ostream& lhs, const menu_item& rhs) {
    return lhs << rhs.title;
}

// menu class constructors
menu::menu(const std::string& title_val) : title{title_val} {}

menu::menu(const std::string& title_val,
           const std::vector<menu_item>& items_val)
    : title{title_val}, items{items_val} {}

menu::menu(const std::string& title_val, const std::string& description_val)
    : title{title_val}, description{description_val} {}

menu::menu(const std::string& title_val, const std::string& description_val,
           const std::vector<menu_item>& items_val)
    : title{title_val}, description{description_val}, items{items_val} {}

// menu class static variables
int menu::nesting_level{0};

// menu class public interface
void menu::add_item(const menu_item& item) { items.push_back(item); }

void menu::add_item(const std::string& title_val, std::function<void()> action_val) {
    items.push_back(menu_item{title_val, action_val});
}

void menu::add_item_at(int index, const menu_item& item) {
    check_index(index);
    items.insert(items.begin() + index, item);
}

void menu::add_item_at(int index, const std::string& title_val,
                       std::function<void()> action) {
    check_index(index);
    items.insert(items.begin() + index, menu_item{title_val, action});
}

void menu::remove_item(int index) {
    check_index(index);
    items.erase(items.begin() + index);
}

void menu::add_submenu(const menu& menu_val) {
    items.push_back(menu_item{menu_val.title, invoke_menu_loop(menu_val)});
}

void menu::add_submenu(const std::string& title_val, const menu& menu_val) {
    items.push_back(menu_item{title_val, invoke_menu_loop(menu_val)});
}

void menu::add_submenu_at(int index, const menu& menu_val) {
    check_index(index);
    items.insert(items.begin() + index,
                 menu_item{menu_val.title, invoke_menu_loop(menu_val)});
}

void menu::add_submenu_at(int index, const std::string& title_val,
                          const menu& menu_val) {
    check_index(index);
    items.insert(items.begin() + index,
                 menu_item{title_val, invoke_menu_loop(menu_val)});
}

void menu::set_title(const std::string& title_val) { title = title_val; }

void menu::set_description(const std::string& description_val) {
    description = description_val;
}

void menu::loop() const {
    bool active = true;
    ++nesting_level;
    while (active) {
        print_title(title);
        if (!description.empty()) {
            std::cout << std::endl;
            std::cout << description;
            std::cout << std::endl;
        }
        char choice = read_choice();
        if (choice == quit_choice) {
            --nesting_level;
            active = false;
        } else {
            std::cout << '\n';
            // call function bound to menu item
            items[choice - '0'].action();
            // wait until user press the enter key
            std::cout << "\nPress enter to continue...\n";
            std::cin.get();
        }
    }
}

// menu class private functions
void menu::print_choices() const {
    for (std::size_t i = 0; i < items.size(); ++i) {
        std::cout << i << ") " << items[i] << std::endl;
    }
    std::cout << "q) ";
    if (nesting_level > 1)
        std::cout << "Back";
    else
        std::cout << "Quit";
    std::cout << std::endl;
}

char menu::read_choice() const {
    std::string user_input;
    char choice;
    bool valid{false};

    std::cout << "What do you want to do?\n";
    do {
        print_choices();
        std::cout << "Your choice: ";
        std::getline(std::cin, user_input);
        if (user_input.length() > 1 || user_input.empty()) {
            std::cout << "Please enter the valid choice.\n";
            continue;
        }
        choice = tolower(user_input.at(0));
        if ((choice - '0') < 0 ||
            (static_cast<std::size_t>(choice - '0') >= items.size() &&
             (choice != quit_choice))) {
            std::cout << "Invalid choice!\n";
        } else {
            valid = true;
        }
    } while (!valid);
    return choice;
}

void menu::check_index(std::size_t index) const {
    const std::size_t max_allowed_idx = items.size() - 2;
    if (index > max_allowed_idx) {
        std::ostringstream oss;
        oss << "index value must be between " << index << " and "
            << max_allowed_idx;
        throw std::out_of_range{oss.str()};
    }
}

// wrapper function for menu::loop
std::function<void()> menu::invoke_menu_loop(const menu& the_menu) {
    return [&the_menu]() { the_menu.loop(); };
}

Interfejs klasy menu w C++

Sun, 23 Feb 2025 15:40:41 +0000

Robię klasę menu w C++ (kod poniżej). Jakie rozwiązanie jest lepsze, oczekiwanie od użytkownika pisanej przeze mnie biblioteki podania na starcie oczekiwanego interfejsu (np. używając list inicjalizacyjnych) w konstruktorze klasy menu czy dodanie do klasy menu metod add_item, remove_item?

Co sądzicie o stworzeniu osobnej klasy menu_item_list służącej do budowania interfejsu z metodami odpowiednio push_back, pop_back i używaniu jej w klasie menu do odwoływania się do elementów menu? Czy jak tworzę klasy będące kontenerami np. menu_item_list czy checkbox_group to dobrze jest tworzone w nich metody nazywać jak w klasach z STL push_back, pop_back, push_front, pop_front itd.?

Jakbym tworzył klasę menu_item_list to chętnie dodałbym metody typu add_submenu. Jak już tworzyć klasę menu_item_list to lepiej nazwać jej metody push_back, pop_back itd. czy lepsze będą nazwy add_item, remove_item, add_submenu?

Mój kod

~/programy_cpp/linked_list ❯ cat main.cpp                                                                                                             16:32:57
#include <iostream>
/*#include <string>*/
/*#include "linked_list.h"*/
#include "menu.h"

void display_sth() {
    std::cout << "test\n";
}

int main() {
    menu_items main_menu_items;
    main_menu_items.push_back(menu_item{"test", menu_item::noop});
    main_menu_items.push_back(menu_item{"display_sth", display_sth});
    menu submenu{"Submenu", {{"test submenu", menu_item::noop}}};
    main_menu_items.push_back(menu_item{"Submenu", invoke_menu_loop(submenu)});
    menu main_menu{"Main menu", main_menu_items};
    main_menu.loop();
    return 0;
}
~/programy_cpp/linked_list ❯ cat menu.h                                                                                                               16:39:44
#ifndef MENU_H
#define MENU_H

#include <iostream>
#include <string>
#include <vector>
#include <functional>

using menu_item_func = std::function<void()>;

void print_title(const std::string& title);

struct menu_item {
    menu_item(const std::string& title_val) : title{title_val}, action{noop} {}
    menu_item(const std::string& title_val, menu_item_func action_val)
        : title{title_val}, action{action_val} {}
    menu_item(const menu_item& item) : title{item.title}, action{item.action} {}

    friend std::ostream& operator<<(std::ostream& lhs, const menu_item& rhs);

    static void noop() { std::cout << "No action defined!\n"; }

    std::string title{};
    menu_item_func action{};
};

using menu_items = std::vector<menu_item>;

class menu {
public:
    menu(const std::string& title_val);
    menu(const std::string& title_val, const std::vector<menu_item>& items_val);
    menu(const menu& menu_val);

    void loop();

private:
    void print_choices() const;
    char read_choice() const;

    static int nesting_level;
    bool active{false};
    std::string title{};
    std::vector<menu_item> items{};
};

std::function<void()> invoke_menu_loop(menu& the_menu);

#endif // MENU_H
~/programy_cpp/linked_list ❯ cat menu.cpp                                                                                                             16:39:48
#include "menu.h"
#include <limits>

int menu::nesting_level = 0;

void print_title(const std::string& title) {
    std::size_t title_len = title.size();
    std::size_t width = title_len + 4;
    for (int i = 0; i < width; ++i) {
        std::cout << "*";
    }
    std::cout << "\n* " << title << " *\n";
    for (int i = 0; i < width; ++i) {
        std::cout << "*";
    }
    std::cout << std::endl;
}

std::ostream& operator<<(std::ostream& lhs, const menu_item& rhs) {
    return lhs << rhs.title;
}

menu::menu(const std::string& title_val) : title{title_val} {
}

menu::menu(const std::string& title_val, const std::vector<menu_item>& items_val)
    : title{title_val}, items{items_val} {
}

menu::menu(const menu& menu_val) {
    for (const menu_item& item : menu_val.items) {
        items.push_back(item);
    }
}

void menu::print_choices() const {
    for (int i = 0; i < items.size(); ++i) {
        std::cout << i << ") " << items[i] << std::endl;
    }
    std::cout << "q) ";
    if (nesting_level > 1)
        std::cout << "Back";
    else
        std::cout << "Quit";
    std::cout << std::endl;
}

char menu::read_choice() const {
    char choice;
    bool valid{false};

    std::cout << "What do you want to do?\n";
    do {
        print_choices();
        std::cout << "Your choice: ";
        std::cin >> choice;
        if ((choice - '0') < 0 || ((choice - '0') >= items.size()) && (choice != 'q')) {
            std::cout << "Invalid choice!\n";
        } else {
            valid = true;
        }
    } while (!valid);
    return choice;
}

void menu::loop() {
    active = true;
    ++nesting_level;
    while (active) {
        print_title(title);
        char choice = read_choice();
        if (choice == 'q') {
            --nesting_level;
            active = false;
        } else {
            // call function bound to menu item
            items[choice - '0'].action();
            // discard input and wait until user press the enter key
            std::cout << "Press enter to continue...\n";
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            std::cin.get();
        }
    }
}

std::function<void()> invoke_menu_loop(menu& the_menu) {
    return [&]() { the_menu.loop(); };
}

Menu w C++ - błąd wykonania programu

Sun, 23 Feb 2025 13:49:02 +0000

Jakiś pomysł skąd błędy w trakcie wykonania programu? Wyjście z terminala poniżej:

~/programy_cpp/linked_list ❯ cat menu.h                                                                                                         ✘ IOT 13:06:46
#ifndef MENU_H
#define MENU_H

#include <iostream>
#include <string>
#include <vector>
#include <functional>

using menu_item_func = std::function<void()>;

void print_title(const std::string& title);

struct menu_item {
    menu_item(const std::string& title_val) : title{title_val} {}
    menu_item(const std::string& title_val, menu_item_func action_val)
        : title{title_val}, action{action_val} {}
    menu_item(const menu_item& item) : title{item.title}, action{item.action} {}
    menu_item& operator=(const menu_item& rhs);

    friend std::ostream& operator<<(std::ostream& lhs, const menu_item& rhs);

    std::string title{};
    menu_item_func action{};
};

using menu_items = std::vector<menu_item>;

class menu {
public:
    menu(const std::string& title_val);
    menu(const std::string& title_val, const std::vector<menu_item>& items_val);
    menu(const menu& menu_val);

    void loop();

    static void noop() { std::cout << "No action defined!\n"; }

private:
    void print_choices() const;
    char read_choice() const;

    static int nesting_level;
    bool active{false};
    std::string title{};
    std::vector<menu_item> items{};
};

#endif // MENU_H
~/programy_cpp/linked_list ❯ cat menu.cpp                                                                                                             13:07:39
#include "menu.h"

int menu::nesting_level = 0;

void print_title(const std::string& title) {
    std::size_t title_len = title.size();
    std::size_t width = title_len + 4;
    for (int i = 0; i < width; ++i) {
        std::cout << "*";
    }
    std::cout << "\n* " << title << " *\n";
    for (int i = 0; i < width; ++i) {
        std::cout << "*";
    }
    std::cout << std::endl;
}

menu_item& menu_item::operator=(const menu_item& rhs) {
    title = rhs.title;
    action = rhs.action;
    return *this;
}

std::ostream& operator<<(std::ostream& lhs, const menu_item& rhs) {
    return lhs << rhs.title;
}

menu::menu(const std::string& title_val) : title{title_val} {
}

menu::menu(const std::string& title_val, const std::vector<menu_item>& items_val)
    : title{title_val}, items{items_val} {
}

menu::menu(const menu& menu_val) {
    for (const menu_item& item : menu_val.items) {
        items.push_back(item);
    }
}

void menu::print_choices() const {
    for (int i = 0; i < items.size(); ++i) {
        std::cout << i << ") " << items[i] << std::endl;
    }
    std::cout << "q) ";
    if (nesting_level > 1)
        std::cout << "Back";
    else
        std::cout << "Quit";
    std::cout << std::endl;
}

char menu::read_choice() const {
    char choice;
    bool valid{false};

    std::cout << "What do you want to do?\n";
    do {
        print_choices();
        std::cout << "Your choice: ";
        std::cin >> choice;
        if ((choice - '0') < 0 || ((choice - '0') >= items.size()) && (choice != 'q')) {
            std::cout << "Invalid choice!\n";
        } else {
            valid = true;
        }
    } while (!valid);
    return choice;
}

void menu::loop() {
    active = true;
    ++nesting_level;
    while (active) {
        print_title(title);
        char choice = read_choice();
        if (choice == 'q') {
            --nesting_level;
            active = false;
        } else {
            items[choice].action();
        }
    }
}
~/programy_cpp/linked_list ❯ cat main.cpp                                                                                                             13:07:41
#include <iostream>
/*#include <string>*/
/*#include "linked_list.h"*/
#include "menu.h"

void display_sth() {
    std::cout << "test\n";
}

int main() {
    menu_items main_menu_items;
    main_menu_items.emplace_back("test", menu::noop);
    main_menu_items.emplace_back("display_sth", display_sth);
    menu main_menu{"Main menu", main_menu_items};
    main_menu.loop();
    return 0;
}
~/programy_cpp/linked_list ❯ ./main                                                                                                                   13:07:47
*************
* Main menu *
*************
What do you want to do?
0) test
1) display_sth
q) Quit
Your choice: 1
/usr/lib/gcc/x86_64-pc-linux-gnu/14/include/g++-v14/bits/stl_vector.h:1130: std::vector<_Tp, _Alloc>::reference std::vector<_Tp, _Alloc>::operator[](size_type) [with _Tp = menu_item; _Alloc = std::allocator<menu_item>; reference = menu_item&; size_type = long unsigned int]: Assertion '__n < this->size()' failed.
zsh: IOT instruction (core dumped)  ./main
~/programy_cpp/linked_list ❯ ./main                                                                                                             ✘ IOT 13:07:51
*************
* Main menu *
*************
What do you want to do?
0) test
1) display_sth
q) Quit
Your choice: 0
/usr/lib/gcc/x86_64-pc-linux-gnu/14/include/g++-v14/bits/stl_vector.h:1130: std::vector<_Tp, _Alloc>::reference std::vector<_Tp, _Alloc>::operator[](size_type) [with _Tp = menu_item; _Alloc = std::allocator<menu_item>; reference = menu_item&; size_type = long unsigned int]: Assertion '__n < this->size()' failed.
zsh: IOT instruction (core dumped)  ./main
~/programy_cpp/linked_list ❯ ./main                                                                                                             ✘ IOT 13:07:55
*************
* Main menu *
*************
What do you want to do?
0) test
1) display_sth
q) Quit
Your choice: q

Konwersja char do int na systemach, które nie używają ASCII

Sun, 23 Feb 2025 11:12:03 +0000

Wczytuję różne znaki od użytkownika za pomocą char ch; std::cin >> ch; w pętli (lub odpowiednika z getchar w C)

Jak zapewnić przenośną konwersję danych w ch na typ int, jeśli użytkownik wpisze znak będący liczbą, która uwzględniałaby systemy nie używające ASCII, odpowiednio w C i w C++?

Czy jest sens przejmować się tego typu konwersjami przy pisaniu programów, które mają coś robić więcej na poważnie niż być prostymi programikami pisanymi w ramach hobby?

Podpięcie AI do własnego Systemu Operacyjnego

Sun, 09 Feb 2025 00:15:15 +0000

Witam, jako iż jestem początkującym programistą C++ z dużymi ambicjami, mam pytanie, czy da się, i jak podpiąć AI do własnego Systemu Operacyjnego?

Podpięcie programu C++ do komputera

Mon, 03 Feb 2025 23:31:18 +0000

Dzień Dobry, mam pytanie, jak mogę podpiąć program napisany w języku C++ do komputera w taki sposób, żeby po uruchomieniu komputera pojawiła się konsola cmd, z pytaniem o login i hasło?

PS: Program mam zrobiony, tylko nie wiem jak i czy da się coś takiego zrobić

assembler i c++ Filtr Do Zdjec

Tue, 21 Jan 2025 20:04:10 +0000

Witam,
Ostatnio pisząc kod w assemblerze, który implementował filtr do zdjęć napotkałem problem. Próbując zloopować kod, tak, żeby bez wychodzenia z konsoli móc ponownie wypróbować filtr, wyrzuca mi wyjątek na wczytywaniu pikseli. Czy ma ktoś pomysł, jaka może być tego przyczyna?
Poniżej wklejam kawałki kodu. Z góry dziękuję za pomoc.

#include <iostream>
#include <fstream>
#include <thread>
#include <omp.h>
#include <chrono>
#include <mutex>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
using namespace cv;

extern "C" void alg(unsigned char* ptr, unsigned char* end_row, int width, int height, int start_row);

void algC(unsigned char* imdata, int width, int height, int channels, int stride) {
    unsigned char* output = new unsigned char[(height + 2) * stride];

    int kernel[3][3] = {
        { -1, 1, 1 },
        { -1, -2, 1 },
        { -1, 1, 1 }
    };

    for (int y = 1; y < height - 1; y++) {
        for (int x = 1; x < width - 1; x++) {
            for (int c = 0; c < channels; c++) {
                int gradient = 0;

                for (int ky = -1; ky <= 1; ky++) {
                    for (int kx = -1; kx <= 1; kx++) {
                        int pixelValue = imdata[(y + ky) * stride + (x + kx) * channels + c];
                        gradient += kernel[ky + 1][kx + 1] * pixelValue;
                    }
                }

                int result = gradient;
                if (result < 0) result = 0;
                else if (result > 255) result = 255;

                output[y * stride + x * channels + c] = static_cast<unsigned char>(result);
            }
        }
    }

    for (int i = 0; i < height * stride; ++i) {
        imdata[i] = output[i];
    }

    delete[] output;
}

// Function to process image sections using the C-based algorithm
void process_image_section_c(unsigned char* imdata, int start_row, int end_row, int width, int channels, int stride) {
    unsigned char* section_imdata = imdata + start_row * stride;
    algC(section_imdata, width, end_row - start_row, channels, stride);
}

// Function to process image sections using the Assembly-based algorithm
void process_image_section_asm(unsigned char* imdata, int start_row, int end_row, int width, int channels, int stride) {
    unsigned char* section_imdata = imdata + start_row * stride;
    int height = end_row - start_row;
    unsigned char* output = new unsigned char[height * stride];
    alg(section_imdata, output, width, height, stride);
    memcpy(section_imdata, output, height * stride);
    delete[] output;
}

int main(int argc, char* argv[]) {
    const char* fileName = "C:/Users/machm/OneDrive - Politechnika Śląska/Pictures/lena.jpg";
    Mat image = imread(fileName, IMREAD_COLOR);

    if (image.empty()) {
        std::cerr << "Error: Could not load image." << std::endl;
        return -1;
    }

    cv::namedWindow("Before Processing", WINDOW_NORMAL);
    cv::imshow("Before Processing", image);
    waitKey(0);

    int width = image.cols;
    int height = image.rows;
    int channels = image.channels();
    int stride = image.step;

    while (true) {
        Mat imcopy = image.clone();
        unsigned char* imcopydata = imcopy.data;

        std::cout << "Choose algorithm to process the image:\n";
        std::cout << "1. C++ Algorithm\n";
        std::cout << "2. Assembly Algorithm\n";
        std::cout << "Enter your choice (1 or 2): ";
        int choice;
        std::cin >> choice;

        if (choice != 1 && choice != 2) {
            std::cerr << "Invalid choice! Please select 1 or 2." << std::endl;
            continue;
        }

        int iterations = 1;


        double totalTime = 0.0;

        for (int i = 0; i < iterations; i++) {
            Mat iterCopy = image.clone();
            unsigned char* iterCopyData = iterCopy.data;

            int num_threads = 1;  // Number of threads
            std::vector<std::thread> threads;
            int rows_per_thread = height / num_threads;
            int remaining_rows = height % num_threads;

            auto start = std::chrono::high_resolution_clock::now();

            for (int t = 0; t < num_threads; t++) {
                int start_row = t * rows_per_thread + std::min(t, remaining_rows);
                int end_row = start_row + rows_per_thread + (t < remaining_rows ? 1 : 0);

                if (choice == 1) {
                    threads.emplace_back(process_image_section_c, iterCopyData, start_row, end_row, width, channels, stride);
                } else {
                    threads.emplace_back(process_image_section_asm, iterCopyData, start_row, end_row, width, channels, stride);
                }
            }

            for (auto& thread : threads) {
                thread.join();
            }

            auto end = std::chrono::high_resolution_clock::now();
            auto duration = end - start;
            totalTime += std::chrono::duration<double>(duration).count();

            // Display processed image for the first iteration only
            if (i == 0) {
                cv::namedWindow("Processed", WINDOW_NORMAL);
                cv::imshow("Processed", iterCopy);
                waitKey(0);
            }
        }

        double averageTime = totalTime / iterations;
        std::cout << "Total Time for " << iterations << " iterations: " << totalTime << "s\n";
        std::cout << "Average Time per iteration: " << averageTime << "s\n";

        char again;
        std::cout << "Do you want to run another test? (y/n): ";
        std::cin >> again;
        if (again == 'n' || again == 'N') {
            break;
        }
    }

    return 0;
}

.DATA
    zero_float dd 0.0, 0.0, 0.0, 0.0       ; 4x float 0.0
    max_float dd 255.0, 255.0, 255.0, 255.0 ; 4x float 255.0
    minus_one dd -1.0, -1.0, -1.0, -1.0
    minus_two dd -2.0, -2.0, -2.0, -2.0
;===================PLAN=====================
;przetwarzac jeden piksel na raz
;1 kanal = 4 bajty (?)
;maske zrobic tak jak clampy
;dodawac do jakiegos innego rejestru
;wsadzac do outputu
;mozna na slowach
;lepiej nie na floatach
.CODE
alg PROC
    push rbp
    mov  rbp, rsp
    push rbx
    push rsi
    push rdi
    push r12
    push r13
    push r14
    push r15
    ; data
    mov r15, rcx                     ; r15 = imdata (wskaźnik na dane obrazu)
    mov r11, r8                      ; r11 = width
    mov r12, r9                      ; r12 = height
    mov r13, [rsp+104]               ; r13 = stride (bajty na wiersz)
    mov r14, rdx                     ; r14 = output
	sub r12, 1                       ; wysokosc -1
    sub r11, 1                      
    mov rbx, 1                       ; zaczynamy od pierwszego wiersza

    ; dane do mnozenia/clampowania
    movaps xmm0, [zero_float]
    movaps xmm1, [max_float]
    movaps xmm2, [minus_one]
    movaps xmm3, [minus_two]

row_loop:
    cmp rbx, r12
    je end_loop             ; jesli wiersz==wysokosc -> koniec

    mov rdi, 1              ; zaczynamy od pierwszej kolumny
col_loop:
    
    cmp rdi, r11
    je next_row             ; jesli kolumna==szerokosc -> nastepny wiersz 
    mov rax, rbx            ; rax = y
    imul rax, r13           ; rax = y * stride
    mov rsi, rdi            ; rsi = x
    imul rsi, 3             ; rsi = x * channels
    add rax, rsi            ; rax = y * stride + x * channels
    mov rcx, rax            ; zapisz wskaznik na piksel w rcx
    lea rax, [r15 + rax]    ; wskaznik na obecny piksel w rax

    xorps xmm13, xmm13        ; rejestr do przetrzymywania sumy kanalow


	movd		xmm4, dword ptr[rax]		; centralny piksel w xmm4
    pxor        xmm5, xmm5                  ; zerowanie xmm5
    punpcklbw   xmm4, xmm5                  ; bajty do slow
    punpcklwd   xmm4, xmm5                  ; bajty do dslow
    cvtdq2ps    xmm4, xmm4                  ; konwersja do float
    mulps       xmm4, [minus_two]           ; mnozenie przez -2 kazdego kanalu
    addps       xmm13, xmm4                 ; dodanie do xmm13 (tutaj bedzie suma wszystkich 3 kanalow)

    sub rax, r13                            ; wiersz do gory
    sub rax, 3                              ; piksel w lewo

    movd		xmm4, dword ptr[rax]        ; lewy gorny piksel w xmm4
    pxor        xmm5, xmm5                   
    punpcklbw   xmm4, xmm5
    punpcklwd   xmm4, xmm5
    cvtdq2ps    xmm4, xmm4
    mulps       xmm4, [minus_one]           ; mnozenie przez -1 kazdego kanalu
    addps       xmm13, xmm4                 ; dodanie do xmm13
    add rax, 3                              ; piksel w prawo
    movd		xmm4, dword ptr[rax]        ; gorny piksel w xmm4
    pxor        xmm5, xmm5
    punpcklbw   xmm4, xmm5
    punpcklwd   xmm4, xmm5
    cvtdq2ps    xmm4, xmm4
    ;mulps       xmm4, [minus_one]           ; mnozenie przez -1 kazdego kanalu
    addps       xmm13, xmm4                 ; dodanie do xmm13

    add rax, 3                              ; piksel w prawo

    movd		xmm4, dword ptr[rax]        ; prawy gorny piksel w xmm4
    pxor        xmm5, xmm5
    punpcklbw   xmm4, xmm5
    punpcklwd   xmm4, xmm5
    cvtdq2ps    xmm4, xmm4
    addps       xmm13, xmm4                 ; dodanie do xmm13 (mnozenie przez 1)

    add rax, r13                            ; wiersz w dol

    movd		xmm4, dword ptr[rax]        ; prawy piksel w xmm4
    pxor        xmm5, xmm5
    punpcklbw   xmm4, xmm5
    punpcklwd   xmm4, xmm5
    cvtdq2ps    xmm4, xmm4
    addps       xmm13, xmm4                 ; dodanie do xmm13 (mnozenie przez 1)

    sub rax, 6                              ; dwa piksele w lewo

    movd		xmm4, dword ptr[rax]        ; lewy piksel w xmm4
    pxor        xmm5, xmm5
    punpcklbw   xmm4, xmm5
    punpcklwd   xmm4, xmm5
    cvtdq2ps    xmm4, xmm4
    mulps       xmm4, [minus_one]           ; mnozenie przez -1 kazdego kanalu
    addps       xmm13, xmm4                 ; dodanie do xmm13

    add rax, r13                            ; wiersz w dol

    movd		xmm4, dword ptr[rax]        ; lewy dolny piksel w xmm4
    pxor        xmm5, xmm5
    punpcklbw   xmm4, xmm5
    punpcklwd   xmm4, xmm5
    cvtdq2ps    xmm4, xmm4
    mulps       xmm4, [minus_one] 
    addps       xmm13, xmm4                 ; dodanie do xmm13 (mnozenie przez 1)

    add rax, 3                              ; piksel w prawo

    movd		xmm4, dword ptr[rax]        ; dolny piksel w xmm4
    pxor        xmm5, xmm5
    punpcklbw   xmm4, xmm5
    punpcklwd   xmm4, xmm5
    cvtdq2ps    xmm4, xmm4
    addps       xmm13, xmm4                 ; dodanie do xmm13 (mnozenie przez 1)

    add rax, 3                              ; piksel w prawo

    movd		xmm4, dword ptr[rax]        ; prawy dolny piksel w xmm4
    pxor        xmm5, xmm5
    punpcklbw   xmm4, xmm5
    punpcklwd   xmm4, xmm5
    cvtdq2ps    xmm4, xmm4
    addps       xmm13, xmm4                 ; dodanie do xmm13 (mnozenie przez 1)

    cvttps2dq xmm7, xmm13                   ; float to int
    packusdw xmm7, xmm7                     ; zapakowanie do slow
    packuswb xmm7, xmm7                     ; zapakowanie do bajtow
    movd edx, xmm7                          ; zapisanie do edx
    lea rax, [r14 + rcx]                    ; wskaznik na piksel w buforze wyjsciowym

    mov dword ptr [rax], edx                ; zapisanie nowego piksela w buforze wyjsciowym
    inc rdi                                 ; inkrementacja kolumny
    jmp col_loop
next_row:
    inc rbx                                 ; inkrementacja wiersza
    jmp row_loop
end_loop:
    pop r15
    pop r14
    pop r13
    pop r12
    pop rdi
    pop rsi
    pop rbx
    pop rbp
    ret

alg ENDP
END

;-------------------------------------------------------------------------
LIBRARY JADll
EXPORTS alg
;-------------------------------------------------------------------------

Po podłączeniu biblioteki SFML do mojego kodu pojawia się błąd kompilacji.

Sun, 05 Jan 2025 17:30:36 +0000

Próbuję podłączyć bibliotekę SFML 3.0, aby działała w Visual Studio Code 2022. Obejrzałem kilka poradników na ten temat i próbowałem to zrobić kilka razy, ale za każdym razem, pomimo że robię wszystko jak na filmikach tutorialowych, pojawia się błąd: "Wystąpiły błędy kompilacji. Czy chcesz kontynuować i uruchomić ostatnią kompilację zakończoną powodzeniem?". Na liście błędów wyświetla się 480 różnych błędów. Zauważyłem, że w poradnikach w katalogu 'bin' znajduje się plik o nazwie 'openal32.dll', a ja tego pliku nie mam i nie wiem, czy to może być problemem. Do testowania, czy biblioteka działa, użyłem kodu z oficjalnej strony SFML.

Ładowanie obrazu w assemblerze

Sun, 05 Jan 2025 13:32:32 +0000

Witam, mam problem związany z assemblerem. Na studiach uczę się assemblera, ale stanąłem pod ściana. dostałem zadanie, które polega na wczytaniu obrazu przy pomocy assemblera i c++. Chciałem wczytać obraz za pomocą c++, następnie przekazać parametry obrazu do assemblera i następnie znowu pokazać wczytany obraz bo przejściu przez assemblera. Mam problem z kodem, nie potrafię wczytać odpowiednio pikseli, jest to może problem z przekazywaniem obrazu bądź też z samym kodem assemblera. Obraz który zwraca mi program odpaleniu go jest "pusty".
Mam trzy pliki:
c++
masm
dll (tylko do przekazania metod)
Za każdą pomoc dziękuje :)

#include <opencv2/opencv.hpp>
#include <iostream>

extern "C" int _fastcall processImage(const unsigned char* inputBuffer, int width, int height, int channels, unsigned char* outputBuffer, int stride);

int main() {
    const char* imagePath = "C:/obraz.jpg";
    cv::Mat image = cv::imread(imagePath, cv::IMREAD_COLOR);

    if (image.empty()) {
        std::cerr << "Error: Could not load the image!" << std::endl;
        return -1;
    }

    cv::Mat outputImage(image.size(), image.type());

    if (!outputImage.data) {
        std::cerr << "Error: Could not allocate memory for output buffer!" << std::endl;
        return -1;
    }

    int stride = image.cols * image.channels();

    int result = processImage(
        image.data,                // Input buffer
        image.cols,                // Image width
        image.rows,                // Image height
        image.channels(),          // Number of channels (e.g., 3 for RGB)
        outputImage.data,          // Output buffer
        stride                     // Stride (width * channels)
    );

    if (result != 0) {
        std::cerr << "Error: Assembly function failed!" << std::endl;
        return -1;
    }

    cv::imshow("Output Image", outputImage);
    cv::waitKey(0);

    return 0;
}

;.586
;.MODEL FLAT, C

.DATA

.CODE

; Set up to load image data and apply a filter (convolution)
; rcx - input image pointer (pixels)
; rdx - output image pointer (pixels)
; r8 - filter pointer (kernel)
; r9 - current byte index (pixel index)
; rsp+40 - stride (width of the image in bytes)

; Purpose of registers:
; r10 - used for iterating through the kernel convolution
; r11 - number of bytes left to process

processImage proc export
    ; Load the amount of bytes to process
    MOV R11, [RSP+40]   ; Amount of bytes left to process
    SUB R11, 8           ; Adjust the byte count (account for stride)

NextPixel:
    MOV R10, R9          ; Set R10 to the current pixel index (center)
    SUB R10, [RSP+40]    ; Adjust to the top middle pixel
    SUB R10, 4           ; Adjust to top-left pixel

    ; Load 3x3 matrix of color-coded pixels into xmm registers
    PMOVZXBD xmm0, [RCX+R10]        ; Top-left
    PMOVZXBD xmm1, [RCX+R10+4]      ; Top-middle
    PMOVZXBD xmm2, [RCX+R10+8]      ; Top-right
    ADD R10, [RSP+40]               ; Move to the next line (stride)
    PMOVZXBD xmm3, [RCX+R10]        ; Middle-left
    PMOVZXBD xmm4, [RCX+R10+4]      ; Middle
    PMOVZXBD xmm5, [RCX+R10+8]      ; Middle-right
    ADD R10, [RSP+40]               ; Move to the next line (stride)
    PMOVZXBD xmm6, [RCX+R10]        ; Bottom-left
    PMOVZXBD xmm7, [RCX+R10+4]      ; Bottom-middle
    PMOVZXBD xmm8, [RCX+R10+8]      ; Bottom-right

    ; Apply the filter (multiply each pixel by the filter value)
    PMOVSXBD xmm9, [R8]             ; Load filter value
    VPBROADCASTD xmm9, xmm9        ; Broadcast filter value to all positions
    PMULLD xmm0, xmm9              ; Multiply top-left pixel by filter
    PMOVSXBD xmm9, [R8+4]           ; Load next filter value
    VPBROADCASTD xmm9, xmm9        ; Broadcast filter value
    PMULLD xmm1, xmm9              ; Multiply top-middle pixel by filter
    PMOVSXBD xmm9, [R8+8]           ; Load next filter value
    VPBROADCASTD xmm9, xmm9        ; Broadcast filter value
    PMULLD xmm2, xmm9              ; Multiply top-right pixel by filter

    ; Repeat for other pixels in the filter (left to right, top to bottom)
    PMOVSXBD xmm9, [R8+12]
    VPBROADCASTD xmm9, xmm9
    PMULLD xmm3, xmm9
    PMOVSXBD xmm9, [R8+16]
    VPBROADCASTD xmm9, xmm9
    PMULLD xmm4, xmm9
    PMOVSXBD xmm9, [R8+20]
    VPBROADCASTD xmm9, xmm9
    PMULLD xmm5, xmm9
    PMOVSXBD xmm9, [R8+24]
    VPBROADCASTD xmm9, xmm9
    PMULLD xmm6, xmm9
    PMOVSXBD xmm9, [R8+28]
    VPBROADCASTD xmm9, xmm9
    PMULLD xmm7, xmm9
    PMOVSXBD xmm9, [R8+32]
    VPBROADCASTD xmm9, xmm9
    PMULLD xmm8, xmm9

    ; Sum the components of the pixels (add the results of the multiplications)
    PADDD xmm0, xmm1
    PADDD xmm0, xmm2
    PADDD xmm0, xmm3
    PADDD xmm0, xmm4
    PADDD xmm0, xmm5
    PADDD xmm0, xmm6
    PADDD xmm0, xmm7
    PADDD xmm0, xmm8

    ; Check if the pixel value is between 0 and 255 (clamp to this range)
Blue:
    MOVD EAX, xmm0
    CMP EAX, 255
    JG BlueGreater
    CMP EAX, 0
    JL BlueLesser

Green:
    MOV [RDX+R9], AL            ; Store the result (Blue component)
    PSRLDQ xmm0, 4              ; Shift the next component (Green)
    MOVD EAX, xmm0
    CMP EAX, 255
    JG GreenGreater
    CMP EAX, 0
    JL GreenLesser

Red:
    MOV [RDX+R9+1], AL          ; Store the result (Green component)
    PSRLDQ xmm0, 4              ; Shift the next component (Red)
    MOVD EAX, xmm0
    CMP EAX, 255
    JG RedGreater
    CMP EAX, 0
    JL RedLesser

Alpha:
    MOV [RDX+R9+2], AL          ; Store the result (Red component)
    MOV EAX, 255
    MOV [RDX+R9+3], AL          ; Set the Alpha component to 255
    ADD R9, 4
    SUB R11, 4
    CMP R11, 0                  ; Check if there are more bytes to process
    JNE NextPixel
    ret

BlueGreater:
    MOV AL, 255                 ; Set Blue to 255 if it's greater
    JMP Green

BlueLesser:
    MOV AL, 0                   ; Set Blue to 0 if it's less
    JMP Green

GreenGreater:
    MOV AL, 255                 ; Set Green to 255 if it's greater
    JMP Red

GreenLesser:
    MOV AL, 0                   ; Set Green to 0 if it's less
    JMP Red

RedGreater:
    MOV AL, 255                 ; Set Red to 255 if it's greater
    JMP Alpha

RedLesser:
    MOV AL, 0                   ; Set Red to 0 if it's less
    JMP Alpha

processImage endp

END

Problem z nauką C++ poprzez zadania

Tue, 24 Dec 2024 14:45:56 +0000

Cześć, uczę się od paru miesięcy C++ czysto hobbystycznie kiedy akurat jest czas. Napotykam problem z utrwalaniem wiedzy.

Zauważyłem że robiąc różne zadania utrwalam w ten sposób jedynie te zagadnienia które już całkowicie zrozumiałem, natomiast nie jestem w stanie przez praktykę lepiej zrozumieć tych z którymi jest mi ciężej. Na przykład jeśli nie jestem w stanie napisać kodu mam często jedynie opcję zobaczenia całej odpowiedzi do zadania czyli kompletnego kodu co potrafi być zniechęcające i dużo lepiej nie rozumiem tego co się zadziało.

Przez to czuję jakbym robił minimalne postępy w nauce. Tym bardziej boję się, że tak samo utknę jeśli będę chciał pobawić się z nauką innego języka programowania.

Spotkaliście się z tym osobiście? Znacie może bazy zadań jakie byłyby tutaj pomocne? Albo i same materiały pomocnicze jak filmiki czy strony o C++ do przejrzenia, które pomogą mi jeszcze lepiej zrozumieć język na tyle żebym mógł radzić sobie z zadaniami.

tablice i ciąg

Mon, 16 Dec 2024 16:20:54 +0000

Potrzebuje pomocy utknęłam i licze na pomoc

#include <iostream>

using namespace std;

int main()
{
    int i , tab[11];
    tab[1]=1;

    for (i=2; i<=11; i++)
    {
    tab[i]=tab[i-1]*3;
    cout << tab[i] << endl;
    }

    return 0;
}

program powinien na początku powinien wyświetlać liczbę 1

Rodzaj palindroma w C++

Mon, 09 Dec 2024 19:41:04 +0000

Co to jest fufsopalindromem. ?

Obiekty w C+ — pytanie o koncept na podstawie problemów w C++

Sun, 08 Dec 2024 06:57:57 +0000

Zwykle programuję w C (a właściwie w jego rozszerzeniu C+), ale zastanawiam się nad obiektowością języka C++.

Wygodnie było by mieć możliwość definiowania obiektów (w C++ nazywanych klasami lub strukturami) w blokach strukturalnych programu, tak by były zwalniane przez kompilator automatycznie po opuszczeniu bloku strukturalnego. Jednak ze względu na sposób, w jaki kompilator obsługuje w programie wynikowym te obiekty, skłaniam się do ich nieużywania. Mianowicie są dwa problemy:

Obiekty są umieszczane na stosie, co zaburza optymalizację rozmiaru stosu, jego ograniczenia do zmiennych tymczasowych, adresów powrotu z procedur — i przewidywalności.
Obiekty są zwalniane przy opuszczaniu bloku strukturalnego programu, co jest naturalne w programie jednozadaniowym (jednowątkowym), ale przeszkadza w programie, w którym następują nieliniowe przełączenia wykonywania. Wiem, że w C++ są operatory “new”/“delete”, ale nie dają mi one nic więcej ponad to, co już mam w C+.

Wymieniłem powyżej dwa problemy (które teraz już zauważam) z obiektami, ale nie te problemy są najważniejsze. One tylko wskazują, iż brakuje innej koncepcji użycia (implementacji przez kompilator) obiektów w języku programowania.

Natomiast teraz zastanowię się nad sensownością użycia obiektów w dotychczasowy sposób.

Można zakładać, że obiekt umieszczony na stosie w bloku strukturalnym programu (na przykład ograniczonym klamrami “{” i “}”) zawiera wewnątrz zmienne, które i tak byłyby użyte, gdyby implementować tę funkcjonalność bez użycia klasy C++. Jednak z moich obserwacji wynika, że klasy zawierają uniwersalne funkcjonalności, które są czasem nadmiarowe względem potrzeb bieżących, więc logiczne, że zawierają wiele zmiennych, które są niepotrzebne w danym kontekście użycia, niewykorzystane. W C+ (opartym bezpośrednio na C, ale bez użycia biblioteki standardowej) rozwiązuję ten problem przez definiowanie obiektu podstawowego i obiektu rozszerzającego, który nie musi być tworzony. Na przykład mam w postaci procedur języka C — definiujących konstruktora, destruktora i metody — obiekt tablicy dynamicznej (zdaje się podobnie jak w C++ “vector”) oraz obiekt rozszerzający: ‘iterator’ elementów tablicy dynamicznej zachowujący poprawny i postępujący stan niezależnie od zmieniana zawartości tablicy. Drugi obiekt korzystając ze zmiennych pierwszego obiektu tworzy własne zmienne tylko wtedy, gdy sam zostanie utworzony, i usuwa je po jego wyrzuceniu (z pamięci), tutaj procedurą destruktora, lub zakończeniu ‘iteracji’.

Powyższy problem mógłby być rozwiązany w C++ przez przydzielanie wewnątrz klasy danych na stercie w przypadku użycia nadmiarowej funkcjonalności. Ale czy tak jest powszechnie robione? Oraz czy to nie wymaga ręcznego zarządzania tworzeniem/wyrzucaniem obiektów wewnątrz takiej klasy, ponieważ nie ma odpowiednich konstrukcji języka programowania?

Ponadto w C+ program wykonuje się w tzw. ‹zadaniach›, które są w powszechnym rozumieniu ograniczonymi wątkami (wirtualnymi lub rzeczywistymi). To powoduje konieczność definiowania zmiennych używanych przez więcej niż jedno ‹zadanie› — w przestrzeni globalnej (poza procedurami). Oczywiście pogrupowałem takie zmienne według zastosowania i umieszczam je w strukturach globalnych. W tym przypadku kompletnie nie mam koncepcji, jak w programie miało by być pomyślane użycie takich zmiennych, w jego składni.

Pytania są następujące. O czym w ogóle piszę: czy taki koncept jest już gdziekolwiek realizowany w języku programowania (w naturalny sposób) i co to za koncept? Jak w hipotetycznej składni programu umieszczać obiekty, które są współdzielone pomiędzy ‹zadaniami›? Jak realizować rozszerzalność obiektów nie w postaci rozbudowy (w C++ dziedziczenie), ale w postaci rozszerzania w przypadku użycia — a to wszystko automatyzowane w składni języka? No i oczywiście pytania z poprzednich akapitów.

⁂

Wiem mniej więcej, co miałem na myśli w tym pytaniu. Zamiast bloków strukturalnych języka programowania potrzebne mi są bloki wykonawcze, w których dane byłyby przechowywane pomiędzy procedurami, bez względu na hierarchię strukturalną programu, i usuwane na końcu. Program wykonuje się zmieniając stany obiektów. W pewnym stanie obiektów jest początek bloku wykonawczego, a w innym stanie obiektów jest koniec tego bloku wykonawczego. Ponieważ program wykonuje się centrycznie wokół wejścia danych (np. “socket”) lub wyjścia danych (np. rysowanie obiektów graficznych w oknie), a nie wokół obiektu tworzonego pobocznie, nie jest możliwe użycie bloku strukturalnego. Pewną próbą podejścia do tej sytuacji (powiązania bloku strukturalnego z wykonawczym) jest znany z języka Python blok strukturalny “with”, ale on umożliwia tylko proste użycia, które u mnie nie mają zastosowania. Globalne kolekcje obiektów, których używam (np. kolekcja otwartych plików) są tylko wąskim zastosowaniem bloku wykonawczego, tzn. tylko dla obiektu otwartego pliku. Pełne zastosowanie bloku wykonawczego wymagałoby tworzenia tymczasowych globalnych (by były dostępne pomiędzy procedurami) obiektów, w których byłyby zmienne bloku wykonawczego.

Wskaźniki problem z wyswietlaniem

Wed, 04 Dec 2024 14:44:38 +0000

Hej mam za zadanie napisać "funkcję, która jako argumenty przyjmuje dwa wskaźniki i działa tak, że oblicza sumę wartości tych wskaźników. Wywołaj tę funkcję by wartości w co drugiej kolumnie zmienić na sumy dwóch sąsiednich w wierszu komórek."

Zrobiłem funkcje ale wyświetlają się tylko te kolumny, które są sumą dwóch sąsiadujących, a chce żeby te sąsiadujące też się wyświetlały, co zrobić aby tak było?

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>





void sumaws(int *x, int *y)
{
    int starex=*x;
    int starey=*y;
    *x=*y;
    *y=starex+starey;

}


int main()
{

    srand(time(0));

    int n;
    printf("Podaj n \n");
    scanf("%d", &n);
    
    printf("\n");

	int **p;
    p=(int**)malloc(n*sizeof(int*));

    for(int i=0; i<n; i=i+1)
    {
       *(p+i)=(int*)malloc(n*sizeof(int));
    }



	for(int i=0; i<n; i=i+1)
    {
        for(int j=0; j<n; j=j+1)
    {
       *(*(p+i)+j)=-9+rand()%(10-(-9));
        printf("%2.d ", *(*(p+i)+j) );
    }
        printf("\n");
    }

      printf("\n\n");


    for(int i=0; i<n; i=i+1)
    {
        for(int j=1; j<n; j=j+2)
    {

        sumaws(   (*(p+i)+j-1) ,  (*(p+i)+j+1)   );

        printf("%2.d ", *(*(p+i)+j+1));
    }
        printf("\n");
    }






   for(int i=0; i<n; i=i+1)
    {
        free(*(p+i));
    }

    free(p);






    return 0;
}

Program tworzący pliki na dysku google

Mon, 02 Dec 2024 17:55:53 +0000

Potrzebuje zrobić program który będzie pobierał sobie dane z mojego dysku google przeliczał a następnie je tam zapisywał pobieranie udało mi się zrobić z pomocą pliku batch ale nie mam pomysłu jak zrobić zapisywanie chciałbym zrobić to tak żeby działało na każdym komputerze czyli najlepiej żeby samo logowało się do dysku i zarządzało danymi

Wskaźniki macierzy nie wyświetla liczby zero

Mon, 02 Dec 2024 17:26:31 +0000

Hej, nie mam pojęcia czemu liczba zero nie jest wyświetlana w macierzy, ilość zer natomiast działa dobrze, i nie mam pomysłu jak to naprawić, z góry dzięki

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>



int main()
{


    int n;
    printf("Podaj n\n");
    scanf("%d", &n);


	int **p, suma=0,sumaprawej=0, ilezer=0;
    p=(int**)malloc(n*sizeof(int*));

    for(int i=0; i<n; i=i+1)
    {
       *(p+i)=(int*)malloc(n*sizeof(int));
    }



	for(int i=0; i<n; i=i+1)
    {
        for(int j=0; j<n; j=j+1)
    {
        *(*(p+i)+j)=-1+rand()%(2-(-1));
        printf("%3.d ", *(*(p+i)+j) );
    }
        printf("\n");
    }



    for(int i=0; i<n; i=i+1)
    {
        for(int j=0; j<n; j=j+1)
    {

        if((*(*(p+i)+j))==0)
        {
            ilezer=ilezer+1;
        }
    }
    }


    for(int i=0; i<n; i=i+1)
    {
        for(int j=0; j<n; j=j+1)
    {

         if(i==j)
        {
            suma=suma+*(*(p+i)+j);
        }

    }
    }


    for(int i=0; i<n; i=i+1)
    {
        for(int j=0; j<n; j=j+1)
    {

        if(i==(n-1-j) || i==j==n)
        {
            sumaprawej=sumaprawej+*(*(p+i)+j);
        }
    }
    }

    printf("Suma na przekatnej lewej: %d\n", suma);
    printf("Suma na przekatnej prawej: %d\n", sumaprawej);
    printf("Ilosc zer: %d\n", ilezer);








    for(int i=0; i<n; i=i+1)
    {
        free(*(p+i));
    }

    free(p);





    return 0;
}

Zamiana wierszy miejscami w macierzy

Mon, 02 Dec 2024 17:19:50 +0000

Hej, chciałbym zamienić ostatni wiersz z przed ostatnim, ale nie mam pojęcia jak to zrobić, temp tutaj nie zadziała, ponieważ używam wskaźników, jak inaczej mógłbym to zrobić?

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>



int main()
{



    int n;
    printf("Podaj n\n");
    scanf("%d", &n);


	int **p, suma=0,sumaprawej=0;
    p=(int**)malloc(n*sizeof(int*));

    for(int i=0; i<n; i=i+1)
    {
       *(p+i)=(int*)malloc(n*sizeof(int));
    }



	for(int i=0; i<n; i=i+1)
    {
        for(int j=0; j<n; j=j+1)
    {
        *(*(p+i)+j)=(i+1)*(j+1);
        printf("%3.d ", *(*(p+i)+j) );
    }
        printf("\n");
    }

    printf("\n");

    for(int i=0; i<n; i=i+1)
    {
        for(int j=0; j<n; j=j+1)
    {

    
        printf("%3.d ", *(*(p+i)+j) );
    }
        printf("\n");
    }





   for(int i=0; i<n; i=i+1)
    {
        free(*(p+i));
    }

    free(p);






    return 0;
}

Sortowanie bąbelkowe wskaźniki

Thu, 28 Nov 2024 18:06:36 +0000

Chce aby wyświetlano 2 razy 20 losowych liczb, ale za drugim razem były posortowane nie malejąco, gdzie tu jest błąd? Z góry dzięki za pomoc

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>

void sortowanie(int n, int *T)
{

    int i,j,x;
    for (i=1; i<n; i++)
    {
       for (j=n-1; j>=i; j--)
        if (T[j-1]>T[j])
       {
           x=T[j];
           T[j]=T[j-1];
           T[j-1]=x;
       }
    }

}

int main()
{

    srand(time(0));

    int *p;

    p = (int*)malloc(20*sizeof(int));

    int najwieksza=-100, najmniejsza=100;
    int druganajwieksza=-99, druganajmniejsza=99;

    for(int i=0; i<20; i=i+1)
    {
        *(p+i)=-99+rand()%(100-(-99));

        printf("%d ",  *(p+i));

    }

    printf("\n");

    for(int i=0; i<20; i=i+1)
    {
        *(p+i)=-99+rand()%(100-(-99));


        int n=20;
        sortowanie(n, (p+i));
        printf("%d ",  *(p+i));


    }

    free(p);

    return 0;
}

Kurs C++ 23 albo 20

Wed, 27 Nov 2024 23:26:27 +0000

Hej, studiuję informatykę i znam podstawy c++, ale głównie starszych wersji, których uczą w liceum. Natomiast na studiach mam obecnie taki przedmiot jak właśnie programowanie w c++, które nie wygląda tak jak się tego spodziewałam. Na ćwiczeniach facet głównie pisze kody w c++ 23, 20 i w ogóle w tych nowszych. Składnia tego języka strasznie różni się od tego co już umiem dlatego poszukuję kursu c++ ale właśnie jakiegoś nowszego. Może znacie taki kurs i moglibyście mi go polecić bo niestety nie mogę znależć nic fajnego.

Pętle while,ify,wczytywanie liczb.

Fri, 25 Oct 2024 06:41:05 +0000

Hej, potrzebuję pomocy w takim zadaniu:

Napisać aplikację, która wczytuje liczby całkowite do momentu aż dwie pierwsze liczby nie pojawią się ponownie w tej samej kolejności. Obliczyć i wydrukować liczbę wczytanych liczb dwucyfrowych podzielnych przez x (x – wczytane przez użytkownika). Zadanie wykonać bez użycia tablic.

Ogólnie to program prawie działa. Tylko kiedy wczytuje się liczby to działa to tylko jak wpisuje się je parami. Mam namyśli że kiedy wczytamy liczby 5,6 i 5,6 to przerwie program. Ale kiedy wczytamy 5,6,7 i 5,6 to pętla tego nie przerywa. Zobaczcie co mam już napisane. Proszę o pomoc.

#include <iostream>

using namespace std;

int main()
{
  int liczba1,liczba2,liczba3,ilosc=0,zmienna1,zmienna2,x;


    cout <<"Podaj x: "<<endl;
    cin >>x;
    cout <<"Podaj swoje liczby" << endl;
    cin >> liczba1>>liczba2;



    if((liczba1>=10)&&(liczba1<=99)&&(liczba1%x==0)){
   ilosc++;
   }
    if((liczba2>=10)&&(liczba2<=99)&&(liczba2%x==0)){
   ilosc++;
   }
   if((liczba1>=-99)&&(liczba1<=-10)&&(liczba1%x==0)){
   ilosc++;
   }
    if((liczba2>=-99)&&(liczba2<=-10)&&(liczba2%x==0)){
   ilosc++;
   }

    while((liczba1!=zmienna1) || (liczba2!=zmienna2)){

        cin>>zmienna1>>zmienna2;
        

    if((liczba3>=10)&&(liczba3<=99)&&(liczba3%x==0)){
   ilosc++;
   }

    if((liczba3>=-99)&&(liczba3<=-10)&&(liczba3%x==0)){
   ilosc++;
   }


  }

cout <<"Ilosc dwucyfrowych podzielnych: "<<ilosc<<endl;


  return 0;
}

szyfrowanie wyrazów

Sat, 19 Oct 2024 12:19:03 +0000

Potrzebuje pomocy

treść:

Napis program szyfrujący Twoje nazwisko.

Działanie programu ma polegać na:

wpisywaniu poszczególnych liter Twojego nazwiska,
zaszyfrowaniu poszczególnej litery o ustalony wcześniej kod,
wyświetleniu zaszyfrowanych liter Twojego nazwiska.

Wykorzystaj zmienne typu char, string, int , polecenia cin, cout, endl, tablice zmiennych do przechowywania zaszyfrowanych znaków, pętlę for.

Narazie mam tyle:

#include <iostream>

using namespace std;

int main()
{
char litera, litera2;
int i;
for (i=1; i<=8; i++)
{
cin >> litera;
litera2 = litera+7;
cout << litera2 << endl;
cout << "Twoj znak to: " << litera << " Nowy znak to: " << litera2 << endl;
}

return 0;
}
I musze upchac gdzies string ale nie wiem gdzie

Pętla while i ify C++

Thu, 17 Oct 2024 19:50:39 +0000

Hejka, potrzebuję pomocy przy zadaniu. Treść:

Napisać program, który wczytuje liczby całkowite aż do wczytania liczby podzielnej
przez M (M- stała) i zarazem większej od obu poprzedników. Wydrukować średnią
wszystkich wczytanych liczb dwucyfrowych.

Zobaczcie co napisałem, ale jakoś tym liczbom dwucyfrowym źle średnią liczy. I nie wiem jak zaznaczyć, żeby liczba była większa od dwóch poprzedników. Pomóżcie pls.

#include <iostream>
#include <cmath>

using namespace std;

int main()
{

    int k;
    int suma=0;
    int ilosc=0;

    while(true){

    cout << "Podaj swoje liczby: " << endl;
    cin >> k;

    if(k%3==0)
        {
        break;
    }

  }


  if(k>=10){

        suma = suma + k ;
        ilosc ++;

        cout << "Srednia liczb dwucyfrowych: "<< double(suma)/ilosc <<endl;

    }

return 0;
}

szyfrowanie wyrazu o długości 8 znaków

Thu, 17 Oct 2024 14:33:44 +0000

Potrzebuje pomocy w napisaniu programu ktory szyfruje dany wyraz uzywajac tablic string cin cout char i petla for

qt 6 konsola polskie znaki problem

Fri, 11 Oct 2024 20:25:49 +0000

Witam, zacząłem się właśnie bawić trochę qt i mam klasyczny w sumie problem z brakiem polskich znaków w konsoli. W microsoft visual studio udało mi się kiedyś znaleźć kilka rozwiązań tego problemu, ba nawet w imgui miałem polskie znaki, ale w qt nic nie działa. Dokładnie mam Qt Creator 14.0.2 i Qt 6.7.3. Próbuje różnych opcji, czytam różne tematy, próbuje różnych metod i nic. testowałem już qtextstream, qdebug, cout, wcout i ciągle są jakieś krzaczki albo brakujące litery. Ogólnie wiem o co chodzi, w qt mam tekst utf8, w konsoli windows jest cp852 wiadomo. Jak debuguje program i np zajrzę do qstringa czy do zwykłego stringa to widzę elegancko polskie litery np klasyczne: Zażółć gęślą jaźń, jak zapisze takiego np qstringa do pliku to też wszystko jest elegancko po polsku. W aplikacji okienkowej qt też nie ma żadnych problemów. Problem jest tylko i wyłącznie z konsolą, jestem na windows 10 jak coś. Testowałem też już różne kody z forów dyskusyjnych, rozmawiałem z czatami ai i nic. Widziałem, że są też jakieś pozmieniane rzeczy np kiedyś było jakieś qtextcodec, a teraz tego nie ma, jest jakieś qstringconverter i z tego co czytałem ma mniejsze możliwości od qtextcodec? Nie wiem może powinienem zainstalować starszą wersję qt np 5, ale czy to coś da?

Przeciążanie operatorów w klasie

Mon, 23 Sep 2024 10:48:46 +0000

Witam,

zacząłem się bawić w klasy w C++. W ramach treningu napisałem swój wektor. Chciałem przeciążyć operator[] w taki sposób, żebym mógł pisać np.

vec[i]=vec[i-1]+3

Dotychczas zwracałem wartość tablicy w indeksie i, ale w takim wypadku nie działa przypisanie do indeksu. Nie wiem jak zrobić by raz vec[i] dawało element jaki przechowuje wektor, a raz wskaźnik na element by można było przypisać wartość.

W skrócie, mój kod wygląda tak:

template <typename Typ> class Wektor
{
    Typ *content;  //zawartosc
    int capacity;  //maksymalna pojemnosc
    int current;  //indeks ostatniej komorki+1

public:
    Wektor();
    ~Wektor();
    Typ get(int index);  //zwraca content[index]
    void push_back(int val);
    
    Wektor& operator=(Wektor& other);  //i to dziala jak powinno

    Typ operator[](int i)
    {
        if(i>=size())  //jesli jest ponad zakresem to blad
            exit(0);
        return get(i);  //zwroc wartosc
    }
}

Z góry dzięki za pomoc.

Problem z zadaniem Urząd statystyczny

Tue, 03 Sep 2024 17:53:53 +0000

Cześć mam problem z zadaniem oto jego treść

Oto moje rozwiązanie:

dane.h

#ifndef DANE_H_INCLUDED
#define DANE_H_INCLUDED
#include<iostream>
#include<cmath>
using namespace std;
struct Firma
{
private:
    string REGON,msc,kodpocztowy,nazwa;
    double przychod,koszt;
public:
    Firma(string r=" ",string m=" ",string k=" ",string n=" ",double p=0.0)
    {
        REGON=r;
        msc=m;
        kodpocztowy=k;
        nazwa=n;
        przychod=p;
    }
    void wypiszOsobe()
    {
        cout<<REGON<<" "<<msc<<" "<<kodpocztowy<<" "<<nazwa<<" "<<przychod<<endl;
    }
    string getREGON(){return REGON;}
    string getMiejscowosc(){return msc;}
    string getKodPocztowy(){return kodpocztowy;}
    string getNazwa(){return nazwa;}
    double getPrzychod(){return przychod;}
    double getKoszty(){return koszt;}
    void ustawPrzychod(double p) {
        przychod = p;
    }
    void ustawKoszt(double k) {
        koszt = k;
    }
    double obliczDochod() const
    {
        return round(przychod-koszt);
    }
    bool czyPoprawnyREGON() const{
        if(REGON.length()!=9)
            return false;

        int wagi[]={8,9,2,3,4,5,6,7};
        int suma=0;

        for(int i=0;i<8;++i)
        {
            if(!isgraph(REGON[i]))
                return false;
            suma+=(REGON[i]-'0')*wagi[i];
        }
        int reszta=suma%11;
        int cyfraKontrolna=(reszta==10) ? 0 :reszta;
        return (cyfraKontrolna == (REGON[8] - '0'));
    }
};
#endif // DANE_H_INCLUDED

kontener.h

#ifndef KONTENER_H_INCLUDED
#define KONTENER_H_INCLUDED
#include"dane.h"
#include<iostream>
#include<iomanip>
#include<fstream>
using namespace std;
struct Lista
{
private:
    struct Node{
         Firma dane;
         Node*nast;
         Node(Firma d,Node*N=nullptr)
         {
             dane=d;
             nast=N;
         }
    };
    Node*pocz;
    int ileJest;
public:
    Lista()
    {
        pocz=nullptr;
        ileJest=0;
    }
    ~Lista()
    {
        Node*nowy=pocz;
        while(nowy!=nullptr)
        {
            Node*szuk;
            szuk=nowy->nast;
            delete szuk;
            szuk=nowy;
        }
    }
    void wypisz()
    {
        int numerWpisu=1;
        Node*nowy=pocz;
        while(nowy!=nullptr)
        {
            cout<<numerWpisu<<endl;
            cout<<fixed<<setprecision(2)<<nowy->dane.obliczDochod()<<endl;
            cout<<nowy->dane.getNazwa()<<endl;
            cout<<nowy->dane.getKodPocztowy()<<" "<<nowy->dane.getMiejscowosc()<<endl;
            cout<<nowy->dane.getREGON()<<endl;
            numerWpisu++;
            nowy=nowy->nast;
        }
    }
    void wstaw(Firma f)
    {
        Node*nowy;
        nowy=new Node(f);
        if(pocz==nullptr)
        {
            pocz=nowy;
            return;
        }
        else
        {
            Node*szuk=pocz;
            while(szuk->nast!=nullptr)
            {
                szuk=szuk->nast;
            }
            szuk->nast=nowy;
        }
        ileJest++;
    }
    void zapisz()
    {
        if (!pocz) return;
        for (Node *i = pocz; i != nullptr; i = i->nast) {
            for (Node *j = i->nast; j != nullptr; j = j->nast) {
                if (i->dane.obliczDochod() < j->dane.obliczDochod()) {
                    swap(i->dane, j->dane);
                }
            }
        }
        ofstream wynikFile("wynik.txt");
        if(!wynikFile.is_open())
        {
            throw logic_error("Blad: Nie mozna otworzyc pliku");
        }
        Node*nowy=pocz;
        int numerWpisu=1;
        while(nowy!=nullptr)
        {
            string regon=nowy->dane.getREGON();
            int pierwszeDwie = stoi(regon.substr(0,2));
            if(pierwszeDwie>=2 && pierwszeDwie<=34 && pierwszeDwie %2==0)
            {
                if(nowy->dane.getPrzychod()>0)
                {
                    wynikFile<<numerWpisu<<endl;
                    wynikFile<<fixed<<setprecision(2)<<nowy->dane.obliczDochod()<<endl;
                    wynikFile<<nowy->dane.getNazwa()<<endl;
                    wynikFile<<nowy->dane.getKodPocztowy()<<" "<<nowy->dane.getMiejscowosc()<<endl;
                    wynikFile<<nowy->dane.getREGON()<<endl;
                }
                else
                {

                    wynikFile<<numerWpisu<<endl;
                    wynikFile<<"0 DO WERYFIKACJI"<<endl;
                    wynikFile<<nowy->dane.getNazwa()<<endl;
                    wynikFile<<nowy->dane.getKodPocztowy()<<" "<<nowy->dane.getMiejscowosc()<<endl;
                    wynikFile<<nowy->dane.getREGON()<<endl;
                }
            }
            numerWpisu++;
            nowy=nowy->nast;
        }
        wynikFile.close();
    }
};
#endif // KONTENER_H_INCLUDED

main.cpp

#include"dane.h"
#include"kontener.h"
#include<iostream>
#include<fstream>
using namespace std;

int main()
{
    string nazwa;
    cout<<"Podaj nazwe pliku: "<<endl;
    cin>>nazwa;
    Lista li;
    try{
        ifstream plik;
        plik.open(nazwa.c_str(),ios::in);
        if(!plik.good())
        {
            throw logic_error("Plik nie dziala");
        }
        string nazwaM,kodPocztowy,msc,REGON;
        double przychod,koszt;
        while(plik>>REGON>>msc>>kodPocztowy>>nazwaM)
        {
            getline(plik, nazwaM);
            Firma f(REGON,msc,kodPocztowy,nazwaM,przychod);
            if (!(plik >> przychod >> koszt)) {
                cerr << "Blad: Niezgodna liczba rekordow w plikach przychod.txt lub koszt.txt" << endl;
                break;
            }
            f.ustawPrzychod(przychod);
            f.ustawKoszt(koszt);
            if(f.czyPoprawnyREGON())
            {
                li.wstaw(f);
            }
            else
            {
                cerr<<"NIEPOPRAWNY REGON"<<REGON<<endl;
            }
        }
        li.wypisz();
        li.zapisz();
        plik.close();
    }catch(exception &e)
    {
        cout<<e.what()<<endl;
    }
    return 0;
}

oto plik testowy przychod.txt

493028210
Krakow 30-001
FirmaB
15000

914112556
Gdansk 80-001
FirmaC
20000

problem polega na tym iż źle zczytuje kwote a na dodatek nie zapisuje danycb do pliku wynik.txt nie mam pomysłu jak go rozwiązać gdize może być błąd według wasz z góry dziękuje za pomoc

Problem z odczytem pliku w C++

Tue, 03 Sep 2024 15:43:56 +0000

Witam, potrzebuje pomocy.
Robię tutorial jestem na odcinku 7 dokładniej
07. PLIKI TEKSTOWE. ZAPIS I ODCZYT Z PLIKU

#include <iostream>
#include <cstdlib>
#include <fstream>
#include <string>

using namespace std;

string imie, nazwisko;
int nr_tel;

int main()
{
    fstream plik;
    plik.open("wizytkowka.txt", ios::in);

    if (plik.good()==false)
    {
        cout << "Plik nie istnieje!";
        exit(0);
    }

    string linia;
    int nr_linii = 1;
    while(getline(plik, linia));
    {
        switch (nr_linii)
        {
        case 1: imie = linia; break;
        case 2: nazwisko = linia; break;
        case 3: nr_tel = atoi(linia.c_str()); break;
        }
        nr_linii++;
    }

    cout << "imie: " << imie << endl;
    cout << "nazwisko: " << nazwisko << endl;
    cout << "nr_tel: " << nr_tel << endl;

    plik.close();

    return 0;
}

Powyższy kod wypluwa w konsoli to:

Gdzie podziały się linie z imieniem i nazwiskiem?

// Visual Studio 2022

kody ansi w c++ problem z usuwaniem odpowiedniej ilosci lini w terminalu

Wed, 28 Aug 2024 02:30:57 +0000

Cześć,

Właśnie tworzę małą (a właściwie dużą...) grę konsolową, i żeby to ładnie wyglądało, postanowiłem używać clear. Ponieważ nie chcę się męczyć z licencjami, zdecydowałem się na użycie kodów ANSI do czyszczenia ekranu. Napotkałem jednak problem: nie wiem, jak zrobić, aby te kody ANSI usuwały automatycznie tylko te linie, które zostały wypisane przez program, a nie cały terminal.

Obecnie mam jedno niewygodne rozwiązanie:

W każdej funkcji, pętli itp., liczę liczbę wypisanych linii, a następnie w razie potrzeby czyszczę odpowiednią ilość linii kodami ANSI.

Zastanawiam się jednak, czy jest prostsze rozwiązanie, dlatego proszę o pomoc.

Z góry dziękuję!

Problem z wypisaniem poprawny danych i problem ze średnią

Sun, 18 Aug 2024 11:14:08 +0000

Cześć mam problem z zadaniem oto jego treść:

problem polega na tym że jak wstawie trzeciego studenta to nie wypisuje jego imienia tylko numer indeksu a na dodatek źle liczy średnią ze wszystkich ocen oto mój kod:

dane.h
#ifndef DANE_H_INCLUDED
#define DANE_H_INCLUDED
#include<iostream>
#include<sstream>
#include<vector>
using namespace std;
struct Student{
private:
    string imie,nazwisko,mail,status;
    int numerAlbumu,rok;
    double srd;
    vector<double> oceny;
public:
    Student(string im=" ",string naz=" ",string ma=" ",int numer=0,int r=0)
    {
        imie=im;
        nazwisko=naz;
        mail=ma;
        numerAlbumu=numer;
        rok=r;
    }
    void wypiszOsobe()
    {
        cout<<imie<<" "<<nazwisko<<" "<<mail<<" "<<numerAlbumu<<" "<<rok<<endl;
    }
    string getImie(){return imie;}
    string getNazwisko(){return nazwisko;}
    string getAdresMail(){return mail;}
    string getStatus(){return status;}
    int getNumerAlbumu(){return numerAlbumu;}
    int getRok(){return rok;}
    vector<double> getOcena(){return oceny;}
    double getSrednia(){return srd;}
    void setSrednia(double s){srd=s;}
    void setStatus(string st){status=st;}
    void addOcena(double ocena) {
        oceny.push_back(ocena);
    }
    double calculateSrednia() {
        if (oceny.empty()) {
            srd = 0.0;
        } else {
            double suma = 0.0;
            for (double ocena : oceny) {
                suma += ocena;
            }
            srd = suma / static_cast<double>(oceny.size());
        }
        return srd;
    }
    void generateEmail()
    {
        ostringstream emailStream;
        emailStream<<"STUD";

        int iloczyn = 1;
        int numer = numerAlbumu;
        while (numer > 0) {
            int cyfra = numer % 10;
            if (cyfra != 0) {
                iloczyn *= cyfra;
            }
            numer /= 10;
        }
        string digits = to_string(iloczyn);
        if(digits.size()>=3)
        {
           digits = digits.substr(digits.size()-3);
        }
        else
        {
            while(digits.size()<3)
            {
                digits="0"+digits;
            }
        }
        emailStream<<digits<<imie[0]<<nazwisko[0]<<"@wsit.pl";
        mail=emailStream.str();
    }
};
#endif // DANE_H_INCLUDED

kontener.h
#ifndef KONTENER_H_INCLUDED
#define KONTENER_H_INCLUDED
#include"dane.h"
#include<iostream>
#include<iomanip>
#include<fstream>
using namespace std;
struct Lista{
private:
    struct Node{
        Student dane;
        Node*nast;
        Node(Student d,Node*N=nullptr)
        {
            dane=d;
            nast=N;
        }
    };
    Node*pocz;
    int ileJest;
public:
    Lista()
    {
        pocz=nullptr;
        ileJest=0;
    }
    ~Lista()
    {
        Node*nowy=pocz;
        while(nowy!=nullptr)
        {
            Node*szuk;
            szuk=nowy->nast;
            delete nowy;
            nowy=szuk;
        }
    }
    void wypisz()
    {
        int numerWpisu=1;
        Node*nowy=pocz;
        while(nowy!=nullptr)
        {
            cout<<numerWpisu<<endl;
            cout<<nowy->dane.getImie()<<" "<<nowy->dane.getNazwisko()<<" "<<nowy->dane.getAdresMail()<<endl;
            cout<<nowy->dane.getNumerAlbumu()<<endl;
            cout<<nowy->dane.getRok()<<endl;
            cout<<fixed<<setprecision(2)<<nowy->dane.getSrednia()<<endl;
            cout<<nowy->dane.getStatus()<<endl;
            numerWpisu++;
            nowy=nowy->nast;
        }
    }
    void wstaw(Student d)
    {
        d.generateEmail();
        Node*nowy;
        nowy = new Node(d);
        if(pocz==nullptr)
        {
            pocz=nowy;
            return;
        }
        else
        {
            Node*szuk=pocz;
            while(szuk->nast!=nullptr)
            {
                szuk=szuk->nast;
            }
            szuk->nast=nowy;
        }
        ileJest++;
    }
    void calculateAverage()
    {
        Node* nowy = pocz;
        while (nowy != nullptr) {
            double srednia = nowy->dane.calculateSrednia();
            if (srednia == 0) {
                nowy->dane.setStatus("DO WERYFIKACJI");
            } else if (srednia >= 3.0) {
                nowy->dane.setStatus("OK");
            } else {
                nowy->dane.setStatus("DO WERYFIKACJI");
            }
            nowy = nowy->nast;
        }
    }
    void zapisz()
    {
        ofstream rok1File("rok1.txt");
        ofstream rok2File("rok2.txt");
        ofstream rok3File("rok3.txt");
        if(!rok1File.is_open() || !rok2File.is_open() || !rok3File.is_open())
        {
            throw logic_error("Blad: Nie mozna otworzyc pliku");
        }
        Node*szuk=pocz;
        int numerWpisu=1;
        while(szuk!=nullptr)
        {
            ofstream* plik;
            if(szuk->dane.getRok()==1)
            {
                plik=&rok1File;
            }
            else if(szuk->dane.getRok()==2)
            {
                plik=&rok2File;
            }
            else if(szuk->dane.getRok()==3)
            {
                plik=&rok3File;
            }
            if(plik)
            {
                *plik<<szuk->dane.getNumerAlbumu()<<endl;
                *plik<<szuk->dane.getNazwisko()<<" "<<szuk->dane.getImie()<<endl;

                if(szuk->dane.getSrednia()>=3.0)
                {
                    *plik<<fixed<<setprecision(2)<<szuk->dane.getSrednia()<<endl;
                }
                else
                {
                    *plik<<"DO WERYFIKACJI!"<<endl;
                }
                *plik<<szuk->dane.getAdresMail()<<endl;
            }
            numerWpisu++;
            szuk=szuk->nast;
        }
        rok1File.close();
        rok2File.close();
        rok3File.close();
    }
};
#endif // KONTENER_H_INCLUDED

main.cpp
#include"dane.h"
#include"kontener.h"
#include <iostream>
#include<fstream>
using namespace std;

int main()
{
    string nazwa;
    cout<<"Podaj nazwe pliku: "<<endl;
    cin>>nazwa;
    Lista li;
    try{
        ifstream plik;
        plik.open(nazwa.c_str(),ios::in);
        if(!plik.good())
        {
            throw logic_error("Plik nie dziala");
        }
        while(plik)
        {
            int numerAlbumu,rok;
            string imie,nazwisko,adresMail;
            int liczbaOcen;

            plik>>numerAlbumu>>nazwisko>>imie>>rok>>adresMail>>liczbaOcen;
            Student student(imie,nazwisko,adresMail,numerAlbumu,rok);
            for(int i=0;i<liczbaOcen;++i)
            {
                double ocena;
                plik>>ocena;
                student.addOcena(ocena);
            }
            li.wstaw(student);
        }
        li.calculateAverage();
        li.wypisz();
        li.zapisz();
        plik.close();
    }
    catch(exception &e)
    {
        cout<<e.what()<<endl;
    }
    return 0;
}

oto dane testowe które wstawiałem

999919 Kowalski Jan 1 5
4 3 4 5 3

899919 Nowak Anna 2 4
2 2 3 2

100004 Lewandowski Robert 1 3
5 4 4

100005 Zielińska Maria 2 2
2 3

100006 Krawczyk Andrzej 3 4
4 4 4 4
Wynik mojego programu:

Pytanie gdzie może leżeć błąd jeśli chodzi o wypisywanie trzeciego studenta i gdzie leży problem z obliczaniem średniej z ocen

Zadanie puzzle z mistrza programowania 2023

Thu, 25 Jul 2024 10:57:14 +0000

Hej, napisałam kod, który działa mi w kompilatorze, ale jak wrzucam na szkopuła to wyświetla signal 11. Na razie tablica jest ustawiona na 1e6, bo na 1e7 jest przekroczenie czasu, więc jeżeli ktoś wie jak można skrócić czas działania programu, to będę wdzięczna za pomoc. Poniżej wrzucam też link do treści zadania ze szkopuła.

https://szkopul.edu.pl/problemset/problem/rZa6uMvtCyNIUH1_U0GNM8SU/site/?key=statement

#include <bits/stdc++.h>
using namespace std;
const int MAX=1e6;
int dzielniki[MAX+2];

void Sito(){
    int zakres=sqrt(MAX);
    for (int i=1; i<=zakres;i++){
        for(int j=i*i; j<=MAX; j++){
            dzielniki[j]=i;
        }
    }
    
}

int main(){
    ios_base::sync_with_stdio(0);   cin.tie(0); cout.tie(0);
    Sito();
	int t, n, ans;
    cin >> t;
    while(t--){
        cin >> n;
        ans=(dzielniki[n]+2)*2+(n/dzielniki[n]+2)*2-4;
        cout << ans << endl;
    }

    return 0;
}

Problem z uruchamianiem pliku binarnego

Wed, 10 Jul 2024 18:44:03 +0000

Witam, napisałem niedawno konsolowy program w C++ i chciałem sprawdzić jego działanie na innej maszynie. Ku mojemu zdziwieniu terminal "wypluł" błędy o braku zainstalowanych bibliotek w systemie. Zdziwiłem się dlatego, że uruchamiałem przecież skompilowany wcześniej plik binarny, a więc same zera i jedynki. Rozumiem, gdyby na etapie kompilacji, g++ "wypluwał" errory o braku bibliotek, bo wtedy miałoby to sens, np. używanie funkcji i metod niezawatych w standardzie C++, ale na etapie uruchamiania pliku binarnego nie powinno być takiego błędu, prawda? No właśnie takie jest moje pytanie. Czy rzeczywiście plik binarny może potrzebować dodatkowych bibliotek?