Forum Pasja Informatyki - C i C++

Jak uruchomić import std; w clang 22.1 i gcc 15.2?

Wed, 11 Mar 2026 15:57:42 +0000

Stosuję te wszystkie opcje, niestety nie działa

g++ -std=c++26 -fmodules -freflection -fsearch-include-path -fmodule-only -c bits/std.cc

clang++: warning: argument unused during compilation: '-freflection' [-Wunused-command-line-argument]
<source>:1:8: fatal error: module 'std' not found
    1 | import std;
      |        ^~~~
1 error generated.

import std;

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

Wyświetlenie enum w println

Wed, 11 Mar 2026 15:53:46 +0000

Witam, jak w nowoczesnym C++23 wyświetlić enumy? Funkcja std::println ich nie wyświetla?

#include <iostream>
#include <print>

enum CardinalDirections {
    North = 25,
    South,
    East,
    West
};

int main()
{
    std::println("Wyświetlenie kierunków i ich wartości symbolicznych");
    std::println("Północ: {}", North);
    std::println("Południe: {}", South);
    std::println("Wschód: {}", East);
    std::println("Zachód: {}", West);
    // std::println("Wyświetlenie kierunków i ich wartości symbolicznych");
    // std::println("Północ: {}", static_cast<int>(North));
    // std::println("Południe: {}", static_cast<int>(South));
    // std::println("Wschód: {}", static_cast<int>(East));
    // std::println("Zachód: {}", static_cast<int>(West));

    CardinalDirections WindDirection = South;

//     if (WindDirection == North) {
//        std::println("Kierunek wiatru to Północ.");
//    } else if (WindDirection == South) {
//        std::println("Kierunek wiatru to Południe.");
//    } else if (WindDirection == East) {
//        std::println("Kierunek wiatru to Wschód.");
//    } else if (WindDirection == West) {
//        std::println("Kierunek wiatru to Zachód.");
//    } else {
//        std::println("Nieznany kierunek.");
//    }

    // std::println("Zmienna WindDirection = {}", WindDirection); // z tym nie działa
    std::println("Zmienna WindDirection = {}", static_cast<int>(WindDirection));
    return 0;
}

Ok, udało mi się uruchomić ten program, ale w std::cout, nie trzeba było korzystać z instrukcji if else.


#include <iostream>
#include <format> // Użycie head de <format>

enum CardinalDirections {
    North = 25,
    South,
    East,
    West
};

int main()
{
    std::println("Wyświetlenie kierunków i ich wartości symbolicznych");
    std::println("Północ: {}", static_cast<int>(North));
    std::println("Południe: {}", static_cast<int>(South));
    std::println("Wschód: {}", static_cast<int>(East));
    std::println("Zachód: {}", static_cast<int>(West));

    CardinalDirections WindDirection = South;

    std::println("Zmienna WindDirection = {}", static_cast<int>(WindDirection));

    if (WindDirection == North) {
        std::println("Kierunek wiatru to Północ.");
    } else if (WindDirection == South) {
        std::println("Kierunek wiatru to Południe.");
    } else if (WindDirection == East) {
        std::println("Kierunek wiatru to Wschód.");
    } else if (WindDirection == West) {
        std::println("Kierunek wiatru to Zachód.");
    } else {
        std::println("Nieznany kierunek.");
    }

    return 0;
}

Mam jeszcze takie pytanie skąd pobrać binarne wersje kompilatorów GCC 16 i LLVM 23 / Clang 23?

Stabilne wersje mogę pobrać stąd.

https://github.com/llvm/llvm-project/releases
https://github.com/xpack-dev-tools/gcc-xpack/releases/tag/v15.2.0-1/

Mogę też wykorzystać inny kompilator Circle ale on zatrzymał się na standardzie C++20.

https://www.circle-lang.org/site/download/

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;
}

Ocena kodu - dwa małe projekty (Github)

Mon, 05 Jan 2026 13:20:02 +0000

Siema, ostatnio napisałem takie 2 małe projekty jako wstęp do troszkę większych. Chciałbym poprosić Was o ocenę kodu, np. czy mam wyrobione jakieś złe nawyki, czy dobrze rozwiązałem problem cross-platform'owości (czyli że program jest dostępny na wiele systemów operacyjnych) i jakieś ogólne opinie na ich temat. Każdy komentarz jest mile widziany. Polecam skompilować i wypróbować samemu po spojrzeniu w kod :D

Link do projektów: https://github.com/polandonion?tab=repositories

PS. zapomniałem dodać, ale to chyba oczywiste - jeśli macie pomysł na jakieś zmiany/ulepszenia w kodzie, to śmiało podrzucajcie PR

Kompilacja Code::Blocks

Wed, 19 Nov 2025 21:04:51 +0000

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
	<FileVersion major="1" minor="6" />
	<Project>
		<Option title="test c++23" />
		<Option pch_mode="2" />
		<Option compiler="gcc" />
		<Build>
			<Target title=" Quick-Debug">
				<Option output="bin/Quick-Debug/test c++23" prefix_auto="1" extension_auto="1" />
				<Option working_dir="bin/Quick-Debug" />
				<Option type="1" />
				<Option compiler="cb1_mingw" />
				<Compiler>
					<Add option="-std=c++20 -g -O0 -Wall -Wextra -Wpedantic" />
				</Compiler>
			</Target>
			<Target title="Analysis-Clang">
				<Option output="bin/Analysis-Clang/test c++23" prefix_auto="1" extension_auto="1" />
				<Option working_dir="bin/Analysis-Clang" />
				<Option type="1" />
				<Option compiler="cb2_clang" />
				<Compiler>
					<Add option="-std=c++20 -g -O0 -Wall -Wextra -Wpedantic -Wshadow -Wconversion -fsanitize=address -fsanitize=undefined" />
				</Compiler>
			</Target>
			<Target title="Release-GCC">
				<Option output="bin/Release-GCC/test c++23" prefix_auto="1" extension_auto="1" />
				<Option working_dir="bin/Release-GCC/" />
				<Option type="1" />
				<Option compiler="cb1_mingw" />
				<Compiler>
					<Add option="-std=c++20 -O2 -march=native -flto -DNDEBUG -Wall -Wextra -Wpedantic" />
				</Compiler>
			</Target>
			<Target title="15.2.0">
				<Option output="bin/15.2.0/test c++23" prefix_auto="1" extension_auto="1" />
				<Option working_dir="bin/15.2.0" />
				<Option type="1" />
				<Option compiler="copy_of_1_mingw" />
				<Compiler>
					<Add option="-std=c++23 -O2 -march=native -flto -DNDEBUG -Wall -Wextra -Wpedantic" />
				</Compiler>
			</Target>
		</Build>
		<Compiler>
			<Add option="-Wall" />
			<Add option="-fexceptions" />
		</Compiler>
		<Unit filename="main.cpp" />
		<Extensions>
			<code_completion />
			<envvars />
			<debugger />
			<lib_finder disable_auto="1" />
		</Extensions>
	</Project>
</CodeBlocks_project_file>

Chcę by szybko tworzyć zapasowe kopie projektu (bez git tylko lokalnie C::B) i mieć możliwość szybkiego ustawienia flag kompilatora. AI proponuje CMake i script.

Jakie są wasze propozycje?

Czy ustawienie flag w ten sposób na sens?

Taki sposób kompilacji 3 typy główne ma sens?

[C++]Potrzebuje pomocy z wyswietlaniem wyniku na pionowe kolumny

Mon, 20 Oct 2025 17:11:17 +0000

#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
    int n;
    char wybor;
    cout<<"Podaj liczbe n: ";
    cin>>n;
    cout<<"Wybierz sposob oblizenia za pomoca skrotu(m-mnozenie/d-dzielenie): ";
    cin>>wybor;
    switch(wybor){
        case 'm':
            if(n>0){
                for(int i=1;i<=n;i++){
                    for(int j=1;j<=n;j++){
                        cout<<i*j<<" |";
                    }
                }
                cout<<" "<<endl;
            }
            else{
                for(int i=1;i>=n;i--){
                    for(int j=-1;j>=n;j--){
                        cout<<i*j<<" |";
                    }
                }
                cout<<" "<<endl;
            }
            case 'd':
            if(n>0){
                for(int i=1;i<=n;i++){
                    for(int j=1;j<=n;j++){
                        cout<<i/j<<" | ";
                    }
                }
                cout<<endl;
            }
            else{
                for(int i=1;i>=n;i--){
                    for(int j=-1;j>=n;j--){
                        cout<<i/j<<" | ";
                    }
                }
                cout<<endl;
            }
            break;
        default:
        cout << "Niepoprawny wybor. Wybierz 'm' lub 'd'." << endl;


    }

    return 0;
}

Pomoc w zadaniu "... albo psikus!" z XV OIJ

Fri, 29 Aug 2025 12:06:43 +0000

Witam, mam problem z w/w zadaniem. Wydaje mi się, że myślę poprawnie jeśli chodzi o to zadanie, ale dostaję tylko 18% (reszta to błędne wyniki), porównując to do tzw. brute force algorytmu, za który dostałem 40% (reszta to przekroczenie czasu). Wygląda na to, że rzeczywiście mój algorytm jest błędny. Próbowałem szukać przykładów dla których brute force odpowiada inaczej niż ten nowy algorytm, ale nie znalazłem nic :(

Nic mi nie przychodzi na myśl w tym momencie, i też nie zadaje tego pytania dlatego, żeby dostać gotowca. Po prostu od czasu do czasu lubię sobie poprogramować i coś nie mogę dalej popchnąć tego zadania. Jakby ktoś mógł podać przykład dla którego mój algorytm odpowiada źle, albo jeżeli to będzie za trudne, to jakoś naprowadzić na ścieżkę do poprawnego rozumowania. Dzięki z góry panowie :D

PS: Może to być bardzo pomocne, albo i też bezużyteczne, ale zauważyłem, że każdy błąd objawia się tym, że mój algorytm daje mniejszy wynik niż powinien.

#include <iostream>

using namespace std;

int cuk[1000000], sum[1000000];

int main() {
    int n;
    cin >> n;
    for (int i = 0; i < n; i ++)
        cin >> cuk[i];

    // inicjacja tablicy sum prefiksowych
    sum[0] = cuk[0];
    for (int i = 1; i < n; i ++)
        sum[i] = sum[i - 1] + cuk[i];

    int par = 0, npa = 0;
    long long ile = 0;
    for (int i = 0; i < n; i ++) {
        // tutaj jeżeli sum[i] będzie parzyste to
        // ziekszy sie par, inaczej zwiekszam npa
        par += (sum[i] % 2 == 0);
        npa += (sum[i] % 2 == 1);

        // glowna czesc algorytmu; jeżeli spotkam liczbe parzysta, to sprawdzam
        // ile poprzednio napotkalem liczb parzystych. tutaj wiem, ze kilka osob
        // zauwazy ze "blednie" dodaje par zamiast par - 1, ale tutaj chodzi o
        // to, ze musze jeszcze dodac jeden przypadek, czyli suma cuk od 0 do i.
        // wyjdzie par - 1 + 1 czyli par.
        // no a jezeli napotkam liczbe nieparzysta to musze spojrzec ile poprzednio
        // spotkalem liczb nieparzystych, czyli dodaje npa - 1; tutaj juz nie mamy
        // tego przypadku, ze suka cuk od 0 do i bedzie parzysta, bo sum[i] jest
        // nieparzysta.
        if (sum[i] % 2 == 0)
            ile += par;
        else
            ile += npa - 1;
    }
    cout << ile << endl;
}

Kompilacja open gothic

Fri, 01 Aug 2025 15:47:05 +0000

Cześć, czy może ktoś z was kompilował projekt open gothic ?

Zainteresował mnie ten projekt ale nie byłem w stanie go kompilować.

Próbowałem na visual studio jednak brakuje mu bibliotek.

Nokia - C++ Developer Summer Trainee

Tue, 29 Apr 2025 22:22:59 +0000

Witam,

Mam zapytanie odnośnie testów w rekrutacji na stanowiska stażowe jako C++ Developer w Nokii.
Czy podchodził ktoś do takiego testu?
Jak on mniej więcej wygląda?
Jakie zagadnienia najlepiej sobie przed takim testem przypomnieć?

Pozdrawiam

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

Dobre źródła do nauki C++

Wed, 23 Apr 2025 05:38:38 +0000

Podrzuci ktoś linki do sprawdzonych źródeł do nauki C++ jak np. stronka cppreference? Czy to prawda że cplusplus należy unikać? Co sądzicie o learncpp? Czy unikalibyście stronek typu medium, dev.to, odpowiedzi na quora? A reddit?

Generalnie to potrzebuję jak najwięcej linków i rad gdzie szukać wskazówek, rozwiązań różnych problemów, opisu co do czego sluży w C++ itp. Dobrze jakby te źródła były na bieżąco aktualizowane i zgodne ze standardem C++

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

funkcje podstawy małe pytanko c++

Thu, 17 Apr 2025 15:00:23 +0000

cześć otóż ostatnio mnie natchnęło i zacząłem bawić się w c++ kiedyś mnie to bawiło i bawi dalej ale szybko porzucam jeszcze teraz z pracą na głowie ojej, mianowicie:

#include <iostream>
#include <ctime>
using namespace std;

int wylosuj(int start, int stop)
{
    int wylosowana = rand() % stop + start;

   return wylosowana;
}
int sprawdz(int a, int b)
{
    int wynik=0;
    for(int i=a; i<b; i++)
    {
        wynik++;
    }
    return wynik;

}


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

    cout << "podaj przedzial liczb do wylosowania (od do)\n";
    int a,b;
    cout << "od: ";
    cin >> a;
    cout << "do: ";
    cin >> b;
    b += 1; //czemu nie dziala to po dodaniu 1 w funkcji
    b = sprawdz(a, b);
    cout << "tu: " << b << endl;// test
    for(int i = 0; i<20; i++){
    int wylosowana;
    wylosowana= wylosuj(a,b);
    cout << wylosowana << endl;
    }

    return 0;
}

tak jak w kodzie czemu nie działa b += 1 w funkcji ?

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 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ć

Moja pierwsza implementacja listy jednokierunkowej

Fri, 17 Jan 2025 11:25:05 +0000

Witam, niedawno zacząłem się uczyć obiektowego C++ na własną rękę i jednym z projektów, które chciałem stworzyć to moja własna implementacja listy jednokierunkowej (link). Wydaje mi się, że dobry przykład na początek, więc chciałbym się zapytać, czy jest ona poprawna, czyli taka, która nie doprowadza do tzw. wycieku pamięci. Na moje oko powinno wszystko grać, ale zawsze lepiej dmuchać na zimne. Po drugie tak sobie myślałem, czy nie dałoby rady wszystkich funkcji zamienić w metody klasy Node, tak aby nie wykonywać funkcji w taki sposób:

addToList(100);

tylko mniej więcej w taki, który jest troszkę nawet bardziej czytelniejszy:

myList.addToList(100);

, czyli w skrócie wywoływać funkcje obiektowo a nie proceduralnie. Nawet jeżeli to możliwe, to nie mam pojęcia jak tego dokonać, gdyż moja lista to przecież tylko wskaźnik na pierwszy element, a nie obiekt, a struktura Node odpowiada za obiekty a nie za wskaźniki. Tak czy siak, dzięki z góry za przesyłane komentarze i odpowiedzi. Pozdrawiam.

Uruchomienie programu w sfml

Wed, 15 Jan 2025 15:52:57 +0000

Napisałem grę xonix w c++ z użyciem biblioteki sfml, ale nie potrafię jej uruchomić. Nie wyskakują żądne błędy i nie wiem co jest nie tak, ponieważ mechanika nie działa tak jak powinna. W programie są 3 klasy kolejno po sobie dziedziczące Enemy Player i Game. Klasa Game posiada metodę run, która z założenia miała po wywołaniu jej w funkcji main, uruchomić cały program.

Game.cpp

#include<SFML/System/Clock.hpp>
#include<SFML/System/Time.hpp>
#include"Game.h"
#include "Player.h"

Game::Game() {
    game_window.create(sf::VideoMode(K * tile_size, W * tile_size), "XONIX"); // tworzenie okna
	game_window.setFramerateLimit(60);
	resetGame();
    set_frame();
    Render();
	Run();
}



void Game::resetGame() {
  
    gPlayer.user_x = 0;
    gPlayer.user_y = 0;
    gPlayer.user_dx = 0;
    gPlayer.user_dy = 0;
    gameplay = true;

    // Reset grid
    set_frame();
    
    occupiedCount = -90;
    calculateOccupiedPercentage();

    // Reset enemies
    for (int i = 0; i < numEnemies; i++) {
        new enemy(); // Reinitialize enemies
    }
}



float Game::calculateOccupiedPercentage() {
    occupiedCount = -90.0;
    int totalCount = ((W - 2) * (K - 2)) - 27; // Pomijamy obramowanie i miejsce na procenty

    for (int i = 0; i < W - 1; i++) {
        for (int j = 0; j < K - 1; j++) {
            if (grid[i][j] == 1) occupiedCount++;
        }
    }

    float occupiedPercentage = (occupiedCount / static_cast<float>(totalCount)) * 100.0f;

    if (static_cast<int>(occupiedPercentage) > 80) {
       // game_window.draw(sLevel_up);
        resetGame();
        
    }
    return occupiedPercentage;
}


void Game::set_frame() {
    for (int i = 0; i < W; i++) {
        for (int j = 0; j < K; j++) {
            if (i == 0 || j == 0 || i == W - 1 || j == K - 1) {
                grid[i][j] = 1; // ustawianie wartości 1 w tablicy dla obramowania
			}
            else {
                grid[i][j] = 0; // ustawianie wartości 0 w tablicy dla pustych pól
            }
        }
    }

    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 10; j++) {
            grid[i][j] = 1; // ustawianie wartości 1 w tablicy dla percentage bar
        }
    }
}



void Game::Render() {
    Texture texture1, texture2, texture3, texture4,texture5; // loading textures
    texture1.loadFromFile("images/tiles.png");
    texture2.loadFromFile("images/gameover.png");
    texture3.loadFromFile("images/enemy.png");
    texture4.loadFromFile("images/level_up.png");

    Sprite sTile(texture1), sGameover(texture2), sEnemy(texture3), sLevel_up(texture4), sPlayer(texture5);
    sLevel_up.setOrigin(100, 100);
    sGameover.setPosition(100, 100);
    sEnemy.setOrigin(20, 20);

    Font font;
    if (!font.loadFromFile("font/agency_fb.ttf")) {
        std::cerr << "Nie udało się załadować czcionki!" << std::endl;
    }

    Text percentageText;
    percentageText.setFont(font);
    percentageText.setCharacterSize(30);
    percentageText.setFillColor(Color::White);
    percentageText.setStyle(sf::Text::Bold);
    percentageText.setPosition(10, 10);

    float occupiedPercentage = calculateOccupiedPercentage();
    percentageText.setString("Occupied: " + std::to_string(static_cast<int>(occupiedPercentage)) + "%");
    game_window.draw(percentageText);

    
    ////////////////////////////////////////////////////////////////////////
    
    set_frame();

    for (int i = 0; i < W; i++) { // rysuje siatke, przeciwnikow i postac gracza
        for (int j = 0; j < K; j++) {
            if (grid[i][j] == 0) continue; // puste pole
            if (grid[i][j] == 1) sTile.setTextureRect(IntRect(0, 0, tile_size, tile_size)); // sciana
            if (grid[i][j] == 2) sTile.setTextureRect(IntRect(54, 0, tile_size, tile_size)); // slad gracza
            sTile.setPosition(static_cast<float>(j * tile_size), static_cast<float>(i * tile_size));
            game_window.draw(sTile);
        }
    }

    sTile.setTextureRect(IntRect(36, 0, tile_size, tile_size));
    sTile.setPosition(user_x * tile_size, user_y * tile_size);
    game_window.draw(sTile);

    RectangleShape black_bar(sf::Vector2f(162, 54));
    black_bar.setFillColor(sf::Color::Black);
    black_bar.setPosition(0, 0);
    game_window.draw(black_bar);

    sEnemy.rotate(10);
    for (int i = 0; i < numEnemies; i++) {
        sEnemy.setPosition(static_cast<float>(tab[i].x), static_cast<float>(tab[i].y));
        game_window.draw(sEnemy);
    }

	game_window.draw(percentageText);


}




void Game::Run() {
    //game_window.create(sf::VideoMode(K * tile_size, W * tile_size), "XONIX"); // tworzenie okna
    //game_window.setFramerateLimit(60);

    while (game_window.isOpen()) {
        while (game_window.pollEvent(event)) {
            if (event.type == sf::Event::Closed) {
                game_window.close();
            }

            if (event.type == sf::Event::KeyPressed) {
                if (event.key.code == sf::Keyboard::Space) {
                    resetGame();
                }
            }
        }
        
        
        // Aktualizujemy stan gry
        gPlayer.clock.restart();
        gPlayer.Move();
        gPlayer.collisions();
        for (int i = 0; i < numEnemies; i++) {
                tab[i].move();
            }
    
        // Sprawdzanie kolizji gracza z przeciwnikami
        for (int i = 0; i < numEnemies; i++) {
            if (grid[tab[i].y / tile_size][tab[i].x / tile_size] == 2) {
                gameplay = false;
            }
        }

        if (!gameplay) {
            game_window.clear();
           // game_window.draw(sGameover);
            game_window.display();
            //sf::sleep(sf::seconds(2)); // Krótka pauza po zakończeniu gry
            resetGame();
            continue;
        }

        // Renderowanie gry
        game_window.clear();
        Render();
        game_window.display();
    }
}

ale po jej wywołaniu, obiekt player nawet się nie pokazuje a obiekty enemy wylatują poza okno. Poniżej załączam resztę kodu

Game.h

#pragma once
#include <SFML/Graphics.hpp>
#include <SFML/Window.hpp>
#include<SFML/System/Time.hpp>
#include <time.h>
#include <iostream>
#include"Player.h"


extern enemy tab[5];
using namespace sf;


class Game: public Player
{
public:
	
	//Sprite sTile, sGameover, sEnemy, sLevel_up;
	float occupiedCount=0;
	sf::RenderWindow game_window;
	sf::Event event;
	Game();
	void resetGame();
	float calculateOccupiedPercentage();
	void set_frame();
	//void Draw();
	void Render();
	void Run();	
	Player gPlayer;
	enemy gEnemy;

};

Player.h

#pragma once
#include <time.h>
#include<Windows.h>
#include<sfml/Window.hpp>
#include"enemy.h"

extern int grid[25][40];
extern int tile_size;
class Game;
extern enemy tab[5];


class Player: public enemy
{
public:
	int user_dx, user_dy, user_x, user_y;
	sf::Clock clock;
	float timer = 0;
	double delay = 0.07;
	Player();
	void Move();
	void collisions();
	int send_components();
	static const int W = 25;
	static const int K = 40;

};

Player.cpp

#include "Player.h"
#include<SFML/Window.hpp>
#include<windows.h>

using namespace sf;


Player::Player()
{
    user_x = 0, user_y = 0, user_dx = 0, user_dy = 0;
    srand(static_cast<int>(time(NULL)));
    float time = clock.getElapsedTime().asSeconds();
    clock.restart();
    timer += time;

}


void Player::Move()
{
    if (Keyboard::isKeyPressed(Keyboard::Left)) { user_dx = -1; user_dy = 0; } // ruchy gracza
    if (Keyboard::isKeyPressed(Keyboard::Right)) { user_dx = 1; user_dy = 0; }
    if (Keyboard::isKeyPressed(Keyboard::Up)) { user_dx = 0; user_dy = -1; }
    if (Keyboard::isKeyPressed(Keyboard::Down)) { user_dx = 0; user_dy = 1; }


    if (timer > delay) // przesuwanie gracza o jedno pole co jakis czas
    {
        user_x += user_dx;
        user_y += user_dy;

        if (user_x < 0) user_x = 0;
        if (user_y < 0) user_y = 0;
        if (user_x > K - 1) user_x = K - 1;
        if (user_y > W - 1) user_y = W - 1;

        if (grid[user_y][user_x] == 2) gameplay = false; // kolizja w wlasnym sladem
        if (grid[user_y][user_x] == 0) grid[user_y][user_x] = 2; // tworzenie sladu
        timer = 0;
    }
}

void Player::collisions() {

    if (grid[user_y][user_x] == 1) // sprawdza czy gracz zamknął obszar i aktualizuje siatke
    {
        user_dx = user_dy = 0;

        for (int i = 0; i < numEnemies; i++)
            tab[i].occupy(tab[i].y / tile_size, tab[i].x / tile_size);

        for (int i = 0; i < W; i++)
            for (int j = 0; j < K; j++)
                if (grid[i][j] == -1) grid[i][j] = 0; // obszar zamnkniety
                else grid[i][j] = 1; // sciany
    }

}


int Player::send_components()
{
    return user_x, user_y, user_dx, user_dy;
}

enemy.h

#pragma once
#include<time.h>
#include <stdlib.h>



static int grid[25][40] = { 0 };
static int tile_size=18;


class enemy{
public:
	static bool gameplay;
	int x, y, dx, dy;
	int numEnemies = 5; // number of enemies
	enemy();
	void move();
	void occupy(int y, int x);
	~enemy() = default;
};

static enemy tab[5];

enemy.cpp

#include "enemy.h"


bool enemy::gameplay=1;


enemy::enemy()
{
	x = 300;
	y = 300;
	dx = 3- rand() % 6;
	dy = 3-rand() % 6;
	void move();
}

void enemy::move()
{
	x += dx;
	if (grid[y / tile_size][x / tile_size] == 1) { dx = -dx; x += dx; }
	y += dy;
	if (grid[y / tile_size][x / tile_size] == 1) { dy = -dy; y += dy; }
}

//zajmowanie planszy
void enemy::occupy(int y, int x)
{
	if (grid[y][x] == 0) grid[y][x] = -1;
	if (grid[y - 1][x] == 0) occupy(y - 1, x);
	if (grid[y + 1][x] == 0) occupy(y + 1, x);
	if (grid[y][x - 1] == 0) occupy(y, x - 1);
	if (grid[y][x + 1] == 0) occupy(y, x + 1);
}

Funkcja main to tylko zdefiniowanie obiektu game klasy Game i wywołanie dla niego metody Run().

Byłbym bardzo wdzięczny, gdyby ktoś chociaż podpowiedział gdzie szukać błędów, bo siedzę nad tym już naprawdę długo a na nic nie wpadłem.

Warcaby w języku c

Mon, 13 Jan 2025 16:48:25 +0000

Hej piszę gre warcaby w języku c, napisałem kilka funkcji, ale niestety coś nie działa, szukałem chwile i nie moge znaleźć błędu, główny problemem jest to że cały czas wyskakuje niepoprawny ruch, a wczęsniej jak pokazywało poprawny ruch to plansza się nie aktualizowała, z góry bardzo dziękuje za pomoc

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



void stworzenieplanszy(char plansza[8][8])

{
    char planszapocz[8][8] =
    {
        {' ','o',' ','o',' ','o',' ','o'},
        {'o',' ','o',' ','o',' ','o',' '},
        {' ','o',' ','o',' ','o',' ','o'},
        {' ',' ',' ',' ',' ',' ',' ',' '},
        {' ',' ',' ',' ',' ',' ',' ',' '},
        {'x',' ','x',' ','x',' ','x',' '},
        {' ','x',' ','x',' ','x',' ','x'},
        {'x',' ','x',' ','x',' ','x',' '}
    };
        //przekazywanie wartosci
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            plansza[i][j] = planszapocz[i][j];
        }
    }
}

void wyswietlenieplanszy(char plansza[8][8])
{
    printf("  a b c d e f g h\n"); // oznaczenie kolumny
    for (int i = 0; i < 8; i++) {
        printf("%d ", i + 1);  // oznaczenie wiersze
        for (int j = 0; j < 8; j++) {
            printf("%c ", plansza[i][j]);
        }
        printf("\n");
    }
}



void poczatek()
{
    printf("tekst 1\n");
    printf("tekst 2\n");
    printf("tekst 3\n");
    printf("\n\n\n");


}


int czymapionki(char gracz, char graczdamka, char plansza[8][8])
{
        for (int i = 0; i < 8; i++)
            {
            for (int j = 0; j < 8; j++)
            {
                if (plansza[i][j] == gracz || plansza[i][j] == graczdamka)
                    {
                    return 1;  // sa jeszcze pionki
                    }
            }
        }
        return 2;  // nie ma pionkow
    }



void zamianaliter(const char *coord, int *x, int *y)
{
    *x = coord[0] - 'a';  // Z literki 'a'-'h' na indeks 0-7
    *y = 8 - (coord[1] - '0');  // Z cyfry '1'-'8' na indeks 7-0
}




int czypoprawnyruch(char plansza[8][8], int poczx, int poczy, int konx, int kony, char gracz)
{
    //  czy ruch jest po przekatnej
    if (konx - poczx != 1 || kony - poczy != 1)
        {
        return 0; // Ruch nie jest po przekatnej o 1
        }

    //  czy docelowe pole jest puste
    if (plansza[konx][kony] != ' ')
        {
        return 0; //docelowe pole nie jest puste
        }

    // czy koñcowe pole nie jest zajete przez pionek gracza
    if (plansza[konx][kony] == gracz)
        {
        return 0; // Na koñcowym polu jest juz pionek gracza
        }

    if (konx >= poczx || kony != poczy + 1)
        {
        return 0; // Ruch nie jest w góre planszy lub nie jest po przekatnej
        }

    // Ruch jest poprawny
    return 1;
}




int czymoznazbic(char plansza[8][8], int poczx, int poczy, int konx, int kony, char gracz, char komputer)
{
    // Sprawdzamy, czy ruch jest o dwa pola po przekatnej
    if (abs(konx - poczx) != 2 || (kony - poczy) != 2)
    {
        return 0; // Ruch musi byc o dwa pola
    }

    // Sprawdzamy, czy pole koñcowe jest puste
    if (plansza[konx][kony] != ' ') {
        return 0; // Koñcowe pole nie jest puste
    }

    // Sprawdzamy, czy na polu poprednim znajduje sie pionek przeciwnika
    int srodx = (poczx + konx) / 2;
    int srody = (poczy + kony) / 2;

    if (plansza[srodx][srody] != komputer) {
        return 0; // Jezeli na srodku nie ma pionka przeciwnika, nie mozna wykonac bicia
    }

    // Bicie jest mozliwe
    return 1;
}



void wykonanieruchu(char plansza[8][8], int poczx, int poczy, int konx, int kony) {
    char temp = plansza[poczx][poczy]; // Zapamietujemy pionek, który wykonuje ruch
    plansza[poczx][poczy] = ' '; // Usuwamy pionek ze starej pozycji
    plansza[konx][kony] = temp; // Ustawiamy pionek na nowej pozycji
}


void wykonaniebicia(char plansza[8][8], int poczx, int poczy, int konx, int kony)
{
    char temp = plansza[poczx][poczy]; // Zapamietujemy pionek, który wykonuje ruch
    int srodx = (poczx + konx) / 2;
    int srody = (poczy + kony) / 2;

    plansza[poczx][poczy] = ' '; // Usuwamy pionek ze starej pozycji
    plansza[srodx][srody] = ' '; // Usuwamy zbitego pionka przeciwnika
    plansza[konx][kony] = temp; // Ustawiamy pionek na nowej pozycji
}








void ruchgracza(char plansza[8][8], char gracz, char komputer)
{
    char poczkord[3], konkord[3]; // Tablica na wspolrzedne w formacie np. "a2"
    int poczx, poczy, konx, kony;

    // Prosba o wprowadzenie wspolrzêdnych
    printf("WprowadŸ wspó³rzêdne pocz¹tkowe (np. a2): ");
    scanf("%s", poczkord);
    printf("WprowadŸ wspó³rzêdne koñcowe (np. a4): ");
    scanf("%s", konkord);

    // Zamiana wspólrzêdnych startowych i koncowych
    zamianaliter(poczkord, &poczx, &poczy);
    zamianaliter(konkord, &konx, &kony);

    if (czypoprawnyruch(plansza, poczx, poczy, konx, kony, gracz))
        {
        // Zwykly ruch
        wykonanieruchu(plansza, poczx, poczy, konx, kony);
        printf("Ruch wykonany.\n");
        }
    else if (czymoznazbic(plansza, poczx, poczy, konx, kony, gracz, komputer))
        {
        // Zbicie
        wykonaniebicia(plansza, poczx, poczy, konx, kony);
        printf("Zbicie wykonane.\n");
        }
    else
        {
        printf("Niepoprawny ruch!\n");
        }
}




























void ruchkomputera()
{

}








int main()

{

    poczatek();

    char plansza[8][8];
    stworzenieplanszy(plansza);

    wyswietlenieplanszy(plansza);

    while(1)
    {

        ruchgracza(plansza, 'x', 'o');
        wyswietlenieplanszy(plansza);







         if (czymapionki('o','O', plansza)==2)
            {
            printf("Gratulacje! Wygrales przeciwnik nie ma juz pionkow.\n");
            break;
            }
        if (czymapionki('x', 'X', plansza)==2)
            {
            printf("Niestety! Przegrales nie masz juz pionkow.\n");
            break;
            }

    }

    printf("Gra zakonczona");








    return 0;
}

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.

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

Zamiana małych liter w duże

Wed, 11 Dec 2024 16:42:26 +0000

Hej, mam za zadanie napisać program, który wyświetli tekst z pliku, po czym zamieni wszystkie małe litery tekstu na duże, powinienem użyć chyba do tego fseek, ale nie wiem jak zrobić. Chce to zrobić aby wyszukać znak małej litery i zamienić go na znak dużej. obecny kod:

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




int main()
{
    FILE*plik;
    plik=fopen("plik.txt", "r" );
    char napis[100];

    while( fgets(napis, 100, plik)!=NULL)
    {
    printf("%s", napis);
    }

    printf("\n");


    fclose(plik);








    fclose(plik);


    return 0;

}

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;
}

SPOJ Flamaster

Tue, 03 Dec 2024 19:29:59 +0000

Witam

Napisałam kod w C++ do zadania Flamaster, opierając się troszkę na kodach innych. Problem jest taki że u mnie wszystko działa a w spoju wywala błędna odpowiedź. Testowałam kod u siebie dla różnych danych i wszystko działa, dlatego nie rozumiem czemu spoj nie chce zaakceptować odpowiedzi. Jestem początkująca i dopiero zaczynam przygodę z programowaniem w C++.

#include <iostream>
#include <string>

using namespace std;

int ile, powtorka;
string napis;

int main()
{
    cin >> ile;

    for(int i = 1; i <=ile; i++)
    {
        cin >> napis;
        char aktualnyZnak;

        for(int j = 0; j < napis.length(); j++)
        {
            powtorka = 1;
            aktualnyZnak = napis[j];
            while(napis[j] == napis[j+1])
            {
                powtorka++;
                j++;
            }
            if(powtorka == 1)
            {
               cout << aktualnyZnak;
            }
            else if(powtorka == 2)
            {
                cout << aktualnyZnak;
                cout << aktualnyZnak;
            }
            else
            {
                cout << aktualnyZnak;
                cout << powtorka;
            }
        }
    }
    return 0;
}

Programy wyświetlający tabele

Mon, 02 Dec 2024 18:24:22 +0000

Hej mam za zadanie zrobić program, który ". Utworzy tablicę rozmiaru n i zapisze do niej n numerów dni w roku odpowiadających datom podanym przez użytkownika używając do tego celu funkcji" Zrobiłem funkcje i trochę się pogubiłem w jaki sposób należy to zrobić? Z góry dzięki

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

int dzienroku(int miesiac, int dzien)

{
    int dr;

	switch(miesiac)
	{

    case 1:
    miesiac=0;
    break;

	case 2:
    miesiac=31;
    break;

    case 3:
    miesiac=31+28;
    break;

    case 4:
    miesiac=31+28+31;
    break;

    case 5:
    miesiac=31+28+31+30;
    break;

    case 6:
    miesiac=31+28+31+30+31;
    break;

    case 7:
    miesiac=31+28+31+30+31+30;
    break;

   	case 8:
    miesiac=31+28+31+30+31+30+31;
    break;

    case 9:
    miesiac=31+28+31+30+31+30+31+31;
    break;

    case 10:
    miesiac=31+28+31+30+31+30+31+31+30;
    break;

    case 11:
    miesiac=31+28+31+30+31+30+31+31+30+31;
    break;

    case 12:
    miesiac=31+28+31+30+31+30+31+31+30+31+30;
    break;

	}

    dr=miesiac+dzien;

    return dr;
}

int main()
{

    int iledat;
    printf("\nIle dat chcesz podac:");
    scanf("%d", &iledat);

    int m2[iledat];
    int d2[iledat];
    int tab[iledat];
    printf("Podaj daty:\n");

    for(int i=0; i<iledat; i=i+1)
    {
        printf("Podaj Miesiac\n");
        scanf("%d", &m2[iledat]);
        printf("Podaj Dzien\n");
        scanf("%d", &d2[iledat]);
    }


      for (int i=0; i<iledat; ++i)
    {
        tab[iledat]=dzienroku(m2[iledat],d2[iledat]);
        printf("%d ", tab[iledat]);
        printf("\n");
    }

    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;
}

Wskaźniki programowanie język c

Mon, 02 Dec 2024 16:25:48 +0000

Witam, program co prawda działa jak powinien, ale na końcu wyświetla, że gdzieś jest błąd, mógłby mi ktoś napisać gdzie dokładnie? 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;
    p=(int**)malloc(n*sizeof(int*));

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

          for(int j=0; j<n; j=j+1)
    {
        *(*(p+i)+j)=(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");
    }


    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);






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



    for(int i=0; i<10; 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.

Liczby losowe programowanie w języku C

Tue, 05 Nov 2024 20:27:59 +0000

Witam mam problem ze zrobieniem lub być może zrozumieniem zadania, otóż mam wykonany poniższy program i muszę w nim napisać kod, który wyświetla liczbe, którą jest cytuje "liczba mówiąca ile kolejnych liczb licząc od końca tablicy tworzy ciąg arytmetyczny (precyzyjniej: największe k, takie że k ostatnich elementów w tablicy jest ciągiem arytmetycznym)". Nie jestem pewien czy dobrze to zrozumiałem, więc może tu jest problem, ale nie wiem jak to zrobić, z góry dziękuje za pomoc

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


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

    int n1, n2;

    printf("Podaj 2 liczby naturalne\n");
    scanf("%d %d", &n1, &n2);

    int mac[n1][n2];


   for (int i=0; i<n1; ++i)
    {
        for (int j=0; j<n2; ++j)
        {
            mac[i][j]=-9+rand()%(10-(-9));
            printf("%d ", mac[i][j]);
        }
        printf("\n");
    }


    return 0;

}

Zamiana string na dwa int'y

Tue, 05 Nov 2024 18:26:37 +0000

Chcialem zbudowac prosty kalkulator. Koduje od okolo miesiaca, ale to moj pierwszy wiekszy projekt (przynajmniej wiekszy od nauki pojedynczej funkcji) i zastanawiam sie jak zamienic string np. 9+10 tak aby utwozyc osobno liczbe 9 i liczbe 10 w postaci int'ow oraz wykryc znak dzialania. Jakies porady? PS: zastanawialem sie nad zakodowaniem tego z uzyciem kodu ascii, gdzie od danej liczby w stringu usune 48 i przeksztalce to na inta:

-> (int(wynik)-'0');

conio.h i fstring sa dodane na przyszlosc aby zrobic miedzy innymi historie dzialan

#include <iostream>

#include <conio.h>

#include <cmath>

#include <fstream>



using namespace std;



string dzialanie;

float wynik,liczba;

int i,n;

int Dodawanie(float wynik, float liczba)

{

wynik = wynik + liczba;

}



int Odejmowanie(float wynik, float liczba)

{

wynik = wynik - liczba;

}



int main(int argc, char *argv[ ])

{

cout<<"Zapisz dzialanie (Kolejnosc wykonywania dzialan jeszcze NIE dodana, wiec dzialania beda wykonywane od lewej do prawej): "<<endl;

cin>>dzialanie;



for(i=0;i=dzialanie.length();i++)

    {

if(dzialanie[i]="+")

        {

     Dodawanie(wynik,liczba);

        }

       

else if(dzialanie[i]="-")

        {

    Odejmowanie(wynik,liczba);

        }

    }

}

Dziekuje za wszelka pomoc. Wiem ze daloby sie zrobic to efektywniej ale nie jestem jeszcze przyzwczajony do logiki komputera. Pozdrawiam wszystkich pomocnych. :)