Forum Pasja Informatyki - Najnowsze z tagiem segmentation-fault

Segmentation fault - jak znależć błąd

Thu, 17 Feb 2022 15:57:11 +0000

#include <iostream>
using namespace std;


void stworzTablice (int **tab, int rozmiar)
{
    *tab = new int [rozmiar];
     for (int i=0; i<rozmiar; i++) {
        *(tab[i]) = 100;
    }
    return;
}

void usunTablice (int **tab);
{
    delete[] *tab;
    return;
}

int main()
{
    int size=100;
    int *tablica=nullptr;
    stworzTablice(&tablica, size);

    usunTablice(&tablica);

    cout << endl;
    return 0;
}

Cześć, ćwiczę wskaźniki i próbuję utworzyć dynamiczną tablicę.

Program się nie wykonuje, a po analizie za pomocą debuggera wychodzi na to, że wywala segmentation fault w pętli for w funkcji stworzTablice przy próbie przypisania wartości dla tab[1] (chociaż wyżej została zaalokowana pamięć dla 100 elementów). Nie mam pojęcia, gdzie jest błąd.

SEG FAULT w wyznaczeniu maksymalnej sumy C++

Sun, 04 Jul 2021 19:01:56 +0000

Cześć,

Na themisie mam zadanie, które przechodzi mi w 1 na 2 egzaminy, 2 wywala mi seg fault. Normalnie pddaję się już, nie wiem, o co chodzi.

Treść zadania jest następująca:

Dla danej planszy liczb nieujemnych podaj maksymalną sumę liczb, jaką można zebrać idąc z lewego narożnika (na górze) do prawego (na dole) w taki sposób, że dozwolone są tylko ruchy w dół lub w prawo.

Wejście
W pierwszej linii wejścia dana jest liczba testów. Każdy test rozpoczyna się dwoma liczbami h, w (1 ≤ h, w ≤ 1000) zadającymi liczbę wierszy i kolumn planszy. Następnie dana jest plansza o tychże wymiarach wypełniona liczbami co do modułu nie większymi od miliona.

Wyjście
Dla każdego testu należy wypisać jedną liczbę – odpowiedź zgodną z opisem w zadaniu.

Przykład
Dla danych wejściowych

2

2 3
1 7 9
2 8 4

3 4
1 1 1 1
2 3 1 7
1 1 2 8
poprawną odpowiedzią jest
21
22

Po czy mój kod:

#include <bits/stdc++.h>
using namespace std;

struct TAB
{
    int val1, val2, vals, valt;
    int tab[1000];

};

int getSum(int BITree[], int index)
{
    int sum = 0;
    while (index > 0) {
        sum = max(sum, BITree[index]);
        index -= index & (-index);
    }
    return sum;
}

void updateBIT(int BITree[], int newIndex,
               int index, int val)
{
    while (index <= newIndex) {
        BITree[index] = max(val, BITree[index]);
        index += index & (-index);
    }
}

int maxSumIS(int arr[], int n)

{
    int newindex = 0, max_sum;

    map<int, int> uniqueArr;

    for (int i = 0; i < n; i++) {
        uniqueArr[arr[i]] = 0;
    }

    for (map<int, int>::iterator it = uniqueArr.begin();
         it != uniqueArr.end(); it++) {

        newindex++;

        uniqueArr[it->first] = newindex;
    }


    int* BITree = new int[newindex + 1];

    for (int i = 0; i <= newindex; i++) {
        BITree[i] = 0;
    }

    for (int i = 0; i < n; i++) {
        max_sum = getSum(BITree, uniqueArr[arr[i]] - 1);

        updateBIT(BITree, newindex,
                 uniqueArr[arr[i]], max_sum + arr[i]);
    }

    return getSum(BITree, newindex);
}


int main()
{
    int num;
    cin >> num;
    if ((num<1) || (num > 1000))
    {
        return 0;
    }
    TAB stokrotki[num];
    for(int i = 0; i < num; i++)
    {
        cin >> stokrotki[i].val1;
        cin >> stokrotki[i].val2;
        stokrotki[i].vals = stokrotki[i].val1 * stokrotki[i].val2;
        stokrotki[i].valt = stokrotki[i].vals + 2;
        stokrotki[i].tab[0] = stokrotki[i].val1;
        stokrotki[i].tab[1] = stokrotki[i].val2;
        for(int j=2; j<stokrotki[i].valt; j++)
        {
            cin >> stokrotki[i].tab[j];
            if((stokrotki[i].tab[j] > 1000000))
            {
                return 0;
            }
        }

    }
    for(int i = 0; i < num; i++)
    {
        int arr[stokrotki[i].valt];
        for(int j=0; j<stokrotki[i].valt;j++)
        {
            arr[j] = stokrotki[i].tab[j];
        }
        int n = sizeof(arr) / sizeof(arr[0]);
        cout << maxSumIS(arr, n) << endl;
    }

    return 0;
}

No dla przykładu z zadania śmiga jak złoto - dla sprawdzianu 1 - złoto , ale sprawdzian 2 kicha.

Czy ktoś byłby w stanie wykryć co zrobiłem nie tak i pokazać w którym miejscu należy poprawić?

Funkcja malloc zgłasza segmentation fault ,gdy próbuję alokować prostą strukturę

Mon, 24 Aug 2020 16:14:05 +0000

Witam. Musiałem zaprojektować prymitywną forward_list w języku C.Mam problem z następującym kodem, który reprezentuje:

typedef struct q_node
{
   int key;
   struct q_node* next;
}q_node;

typedef struct queue
{
    size_t size;
    struct q_node* tail;
    struct q_node* head;
}queue;

q_node* make_node(int new_key)
{
   /* TUTAJ ZGŁASZA WYJĄTEK*/ q_node* new_node = malloc(sizeof (struct q_node));
    new_node->key = new_key;
    new_node->next = NULL;
    return new_node;
}

void queue_push_back(struct queue* queue,int new_key)
{
    //wywołuje funkcję make_node()
}

Problem polega na tym ,że funkcja malloc zgłasza wyjątek segmentation fault ,w funkcji make_node () ( sprawdzałęm w debugerze) . Ktoś wie dlaczego może tak być ? Z góry dziękuję za pomoc :D

Podejrzenie błędu alokacji pamięci - język C - kod błędu 139 (segmentation fault).

Sat, 16 May 2020 18:20:59 +0000

Dobry wieczór,

mam pewien problem ze stworzeniem prostego programu, który oblicza sumę i średnią z wartości umieszczonych w tablicy. Kompilując program nie mam błędu, natomiast narzędzia do testów pokazują taki błąd: Program przerwany; kod błędu=139 (Sygnał SIGSEGV).

To jest mój kod (działa dla małej ilości danych):

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

//int sum(const float* tab, unsigned int size, float *result);
//int avg(const float* tab, unsigned int size, float *result);
//int read_vector_float(float *vec, int size, float stop_value);

int i = 0;

int read_vector_float(float *vec, int size, float stop_value){
    printf("Podaj liczby: ");
    if(size < 0 || size > 100){
        return -1;
    }
    for(i=0; i < size; i++){
        if(scanf("%f", &*vec) != 1){
            printf("Incorrect input");
            return -2;
        }
        if(*vec == stop_value) {
            break;
        }
        ++vec;
    }
    return i;
}

int sum(const float* tab, unsigned int size, float *result){
    if(size > 100){
        return 1;
    }
    for(int j=0; j < i; j++){
        *result = *result + *tab;
        ++tab;
    }
    return 0;
}

int avg(const float* tab, unsigned int size, float *result){

    double sum = 0;
    for(int j=0; j < (int)size; j++){
        sum += *tab;
        ++tab;
    }
    *result = (float)sum / (float)size;
    return 0;
}

int main() {


    float T[100] = {0};
    float *tPointer;
    tPointer = (float*)&T;
    float result = 0;
    float *pResult;
    pResult = (float*)&result;
    read_vector_float(tPointer, 100, 0);
    sum(tPointer, i, pResult);
    printf("Suma: %.2f\n", result);
    result = 0;
    avg(tPointer, i, pResult);
    printf("Srednia: %.2f\n", result);
    return 0;
}

Narzędzie do testowania funkcji avg wprowadza ogromną tablicę (niezwiązaną z moją tablicą T[100]), w polu size jest np. 1200 elementów. Mój kod nie posiada praktycznie żadnych zabezpieczeń wskazanych w poleceniu, ale to jeszcze przede mną. Chciałbym nauczyć się rozwiązywać problemy z dynamiczną alokacją pamięci, a tu jest moim zdaniem problem. Prawdopodobnie brakuje mi którejś z tych funkcji: malloc, calloc lub free. Czy mogę prosić o wskazówki? Męczę się z tematem już 5-6 godzin.

Jako dodatek załączam fragment z oprogramowania do testowania:

Źródło błędu SIGSEGV wykryto w funkcji avg, plik main.c:45
Widok kodu źródłowego:



int avg(const float* tab, unsigned int size, float *result){

    double sum = 0;
    for(int j=0; j < (int)size; j++){
        sum += *tab;       //tutaj jest błąd
        ++tab;
    }
    *result = (float)sum / (float)size;
    return 0;

Z góry dziękuję za podpowiedzi.

Problem z seg.fault

Tue, 21 Apr 2020 13:20:49 +0000

Dzień dobry.

Mam pewien kod i tak jak w temacie spradzaczka pokazuje mi seg.fault.

#include <iostream>
#include<vector>
#include<algorithm>
using namespace std;
int xd;

main()
{
    char macierz[10007][10007];
    int maks=0,n,m,a,b;
    vector <int> tab[100000];
    for(int i=0; i<10000;i++){
        for(int j=0;j<10000;j++){
            macierz[i][j]=0;}

    }
    cin>>n>>m;
    for(int z=0;z<m;z++)
    {
        cin>>a>>b;

        macierz[a-1][b-1]=1;
        macierz[b-1][a-1]=1;
        tab[a].push_back(b);
        tab[b].push_back(a);
        if(a>maks)
        {
            maks=a;
        }
        if(b>maks)
        {
            maks=b;
        }
    }
    cout << endl;
    cout<<"Macierz:"<<endl;
    for(int i=0;i<maks;i++)
    {
        for(int j=0;j<maks;j++)
        {
            cout<<static_cast<int>(macierz[i][j])<< " ";
        }
        cout<<endl;
    }

    cout<<endl;
    cout<<"Lista;"<<endl;
    for (int i=1;i<=n;i++)
    {
        sort(tab[i].begin(),tab[i].end());
        cout <<i<<":"<<" ";
        for (int x=0; x<tab[i].size(); x++)
        {
            if(tab[i][x]==tab[i][x+1])
            {
                i=i;
            }
            else
                cout<<tab[i][x]<<" ";
        }
        cout<<endl;
    }

}

Dlaczego?

[C] Segmentation fault

Wed, 08 Apr 2020 19:44:04 +0000

Hej, właśnie skończyłem program który generuje system

i dostaje oczekiwany efekt ale pojawia się Segmentation Fault i nie mogę się go pozbyć. Może ktoś z was znajdzie przyczynę :D

Segmentation fault

Sun, 15 Mar 2020 18:43:48 +0000

Uczę się asemblera x86 w środowisku Linux. Napisałem prosty program jednak zwraca on segmentation fault. Już za długo szukam miejsca gdzie odwołuję się do nieprzydzielonej pamięci dlatego proszę Was o pomoc.

Program szuka największej liczby


.section data.

data_items:
.long 3,67,34,222,45,76,45,43,444,99,0

.section .text
.globl _start
_start:
movl $0, %edi
movl data_items(,%edi,4), %eax # przy wykonywaniu tego daje seg. fault-a
movl %eax, %ebx



start_loop:
cmpl $0, %eax
je loop_exit
incl %edi
movl data_items(,%edi,4), %eax
cmpl %ebx, %eax
jle start_loop
movl %eax, %ebx
jmp start_loop

loop_exit:

movl $1, %eax
int $0x80

Segmentation fault - C++

Thu, 12 Mar 2020 16:12:56 +0000

Mam problem. Polega on na tym, że kiedy watrość zmiennej b jest zbyt duża, wyskakuje błąd exited, segmentation fault. Co ciekawe, błąd nie pojawia się przy liczbach mniejszych niż 259560 (debug) / 259564 (release). Watro dodać, że zmienna a jest zawsze mniejsza od b. Oto mój kod:

#include <iostream>
#include <algorithm>

using namespace std;

int oblicz_sume(int liczba)
    {
        int wynik=0;
        do
        {
            wynik=wynik+liczba%10;
            liczba=liczba/10;
        }while(liczba!=0);
    return wynik;
}
int main()
{
    int a, b;
    cin >> a >> b;
    int roz = b-a+1;
    int numer[roz];
    for(int i = a; i <= b; i++){
        numer[i-a] = i;
    }
    int suma[roz];
    string ctrl;
    for(int i = 0; i < roz; i++){
        suma [i] = oblicz_sume(numer[i]);
    }
    sort(suma, suma + roz);
    cout << suma[roz-1];
    return 0;
}

Proszę o szybką pomoc.

exited, segmentation fault - C++

Mon, 16 Dec 2019 21:40:10 +0000

Mam problem. Mianowicie po wpisaniu wejścia wyskakuje mi błąd: exited, segmentation fault. Prawdopodobnie wynika on z tego, że funkcja wywołuje sama siebie, ale jakoś nie chce mi się w to wierzyć. Zależy mi na jak najszybszej odpowiedzi. Oto kod:

#include <iostream>

using namespace std;

long long int par(long int n){
    return 10 * par(n / 5) + (n % 5) * 2;
}

int main() {
  long int n;
  cin>>n;
  cout<<par(n);
  return 0;
}

Alokacja pamięci,lista,segmentation fault

Sun, 01 Dec 2019 02:15:19 +0000

#include "intLinkedList.h"

IntLinkedList::IntLinkedList()
{
	head=NULL;
	tail=NULL;
}

IntLinkedList::~IntLinkedList()
{
	isEmpty();
}

int IntLinkedList::size()
{
	int size=0;
	struct Element* temp = head;
	if(temp==NULL)
		return size;
    while (temp != tail) {
		head = temp->next;
		size++;
	}

	return size;
}

int IntLinkedList::isEmpty()
{
	if(head==NULL)
		return 1;
	else
		return 0;
}

void IntLinkedList::print()
{	
	struct Element* temp = head;
	int size=0;
	while (temp != tail) {
		head = temp->next;
		size++;}
	std::cout << "[";
    for(int i=0;i<size;i++){
        std::cout << temp->value;
        if(i<(size-1))
            std::cout << ",";
    }
        std::cout << "]\n";
}

void IntLinkedList::append(int val)
{
	struct Element* new_el= new struct Element;
	
	if (new_el==NULL){
		printf("Blad!\n");
		return;
	}
	
	
	new_el->value=val;
	head->next=NULL;
	
	if(head==NULL){
		head=new_el;
		
	}else{
		struct Element *temp=head;
		
		while(new_el->next != NULL){	
		
			new_el=new_el->next;
		}		
			temp->next=NULL;
    }
}

plik nagłówkowy

#pragma once
#include <iostream>


struct Element{
    int value;
    struct Element *next;

};

class IntLinkedList{
    
private:
	struct Element* head;
	struct Element* tail;
public:
	IntLinkedList();
	~IntLinkedList();
	int size(); //funkcja zwracajaca rozmiar listy
	int isEmpty(); //funkcja sprawdzająca czy lista jest pusta czy nie
	void print(); // drukuje listę w postaci [w1, w2, w3]
	void append(int); //wstawia wartość na koniec listy
			
};

Mianowicie mam problem z rozwiązaniem problemu:
segmentation fault pojawia mi się przy wywołaniu funkcji append

valgrind pokazuje:

"Invalid write of size 8
==323== at 0x108D0C: IntLinkedList::append(int)
.....
HEAP SUMMARY:
==323== in use at exit: 16 bytes in 1 blocks
==323== total heap usage: 3 allocs, 2 frees, 76,816 bytes allocated

...."

Segmentation fault, Debugger i dziwne zachowania.

Sun, 18 Nov 2018 12:43:43 +0000

Dzień dobry!

Od kilku tygodni "Użeram" się z pewnym programem. Miał on za zadania wygenerować mapę na układzie współrzędnych kartezjański. Nie jest to ważne. Najistotniejsze jest to, że używa on bardzo często szybkiej alokacji i zwalniania pamięci. Program jest podzielony na ok. 7 plików, które nie służą tylko w celu generowania tej mapy. Znajomość tego kodu nie jest potrzebna (Najprawdopodobniej) do odpowiedzi na moje pytanie. Uwaga: w kodzie została użyta nie deklarowana wcześniej klasa szablonowa Vector<type> z typdefem Vector2i jest to klasa posiadająca po prostu dwie zmienne x i y typu całkowitego. Wyślę główne segmenty:

//GŁÓWNY PLIK GENERATORA
#ifndef MAP_H_INCLUDED
#define MAP_H_INCLUDED

#include "Room.h"
#include <time.h>

class Map
{
public:
    Room * rooms;

    void generateMap(unsigned short roomsNumber)
    {
        std::cout << "Prakwiecie" << std::endl;
        if(rooms)
            delete rooms;
        rooms = new Room[roomsNumber];
        rooms[0].setCoordinates(0, 0);

        std::cout << "Poprakwiecie" << std::endl;

        unsigned int * roomsToGenerate = new unsigned int[1];
        unsigned short numOfRoomsToGen = 1;
        roomsToGenerate[0] = 0;

        unsigned int id = 0;

        while(id < roomsNumber - 1)
        {
            unsigned int wasRoom;
            unsigned int crashShield;
            wasRoom = 0;
            crashShield = 0;

            SideVector possibleWays;
            possibleWays = checkNearby(rooms, roomsNumber, rooms[roomsToGenerate[0]]);

            std::cout << "Zakwiecie" << std::endl;

            do
            {
                std::cout << "Zasrokwiecie" << std::endl;
                //if(rand() % 3 == 1 && id < roomsNumber - 1 && !possibleWays.Up && !isNotColliding(rooms, roomsNumber, rooms[roomsToGenerate[0]].coordinates + Vector2i(0, -1), Side::Down))
                if(id < roomsNumber - 1 && !possibleWays.Up && !isNotColliding(rooms, roomsNumber, rooms[roomsToGenerate[0]].coordinates + Vector2i(0, -1), Side::Down))
                {
                    rooms[roomsToGenerate[0]].addDoor(rooms + id + 1, Side::Up);
                    rooms[id + 1].addDoor(&rooms[roomsToGenerate[0]], Side::Down);

                    rooms[id + 1].setCoordinates(rooms[roomsToGenerate[0]].coordinates.x, rooms[roomsToGenerate[0]].coordinates.y - 1);

                    addNew(&roomsToGenerate, numOfRoomsToGen, id + 1);
                    numOfRoomsToGen++;

                    id++;
                    wasRoom++;
                    std::cout << rooms[id].coordinates << " " << numOfRoomsToGen << std::endl;
                }

                std::cout << "Srodkwiecie" << std::endl;

                //if(rand() % 3 == 1 && id < roomsNumber - 1 && !possibleWays.Down && !isNotColliding(rooms, roomsNumber, rooms[roomsToGenerate[0]].coordinates + Vector2i(0, 1), Side::Up))
                if(id < roomsNumber - 1 && !possibleWays.Down && !isNotColliding(rooms, roomsNumber, rooms[roomsToGenerate[0]].coordinates + Vector2i(0, 1), Side::Up))
                {
                    rooms[roomsToGenerate[0]].addDoor(rooms + id + 1, Side::Down);
                    rooms[id + 1].addDoor(&rooms[roomsToGenerate[0]], Side::Up);

                    rooms[id + 1].setCoordinates(rooms[roomsToGenerate[0]].coordinates.x, rooms[roomsToGenerate[0]].coordinates.y + 1);

                    addNew(&roomsToGenerate, numOfRoomsToGen, id + 1);
                    numOfRoomsToGen++;

                    id++;
                    wasRoom++;
                    std::cout << rooms[id].coordinates << " " << numOfRoomsToGen << std::endl;
                }

                //if(rand() % 3 == 1 && id < roomsNumber - 1 && !possibleWays.Right && !isNotColliding(rooms, roomsNumber, rooms[roomsToGenerate[0]].coordinates + Vector2i(1, 0), Side::Left))
                if(id < roomsNumber - 1 && !possibleWays.Right && !isNotColliding(rooms, roomsNumber, rooms[roomsToGenerate[0]].coordinates + Vector2i(1, 0), Side::Left))
                {
                    rooms[roomsToGenerate[0]].addDoor(rooms + id + 1, Side::Right);
                    rooms[id + 1].addDoor(&rooms[roomsToGenerate[0]], Side::Left);

                    rooms[id + 1].setCoordinates(rooms[roomsToGenerate[0]].coordinates.x + 1, rooms[roomsToGenerate[0]].coordinates.y);

                    addNew(&roomsToGenerate, numOfRoomsToGen, id + 1);
                    numOfRoomsToGen++;

                    wasRoom++;
                    id++;
                    std::cout << rooms[id].coordinates << " " << numOfRoomsToGen << std::endl;
                }
                std::cout << "Drusrukwiecie" << std::endl;

                //if(rand() % 3 == 1 && id < roomsNumber - 1 && !possibleWays.Left && !isNotColliding(rooms, roomsNumber, rooms[roomsToGenerate[0]].coordinates + Vector2i(-1, 0), Side::Right))
                if(id < roomsNumber - 1 && !possibleWays.Left && !isNotColliding(rooms, roomsNumber, rooms[roomsToGenerate[0]].coordinates + Vector2i(-1, 0), Side::Right))
                {
                    rooms[roomsToGenerate[0]].addDoor(rooms + id + 1, Side::Left);
                    rooms[id + 1].addDoor(&rooms[roomsToGenerate[0]], Side::Right);

                    rooms[id + 1].setCoordinates(rooms[roomsToGenerate[0]].coordinates.x - 1, rooms[roomsToGenerate[0]].coordinates.y);

                    addNew(&roomsToGenerate, numOfRoomsToGen, id + 1);
                    numOfRoomsToGen++;

                    wasRoom++;
                    id++;
                    std::cout << rooms[id].coordinates << " " << numOfRoomsToGen << std::endl;
                }

                crashShield++;
                std::cout << "lol" << std::endl;
            }
            while(!wasRoom && crashShield < 10 && id < roomsNumber - 1);

                delFirst(&roomsToGenerate, numOfRoomsToGen);
                numOfRoomsToGen--;

                std::cout << "Kwiecie" << std::endl;
        }
        std::cout << "Pokwiecie" << std::endl;
        return;
    }

    ~Map()
    {
        delete rooms;
    }
};

#endif // MAP_H_INCLUDED

//PLIK POKOJU
#ifndef ROOM_H_INCLUDED
#define ROOM_H_INCLUDED

#include "Door.h"

class Room
{
public:

    Door * doors;
    unsigned int doorsNumber = 0;
    Vector2i coordinates;

    Room() :coordinates(0, 0) {}

    Room(Door * cDoors, unsigned int cDorNum, Vector2i cCor) :coordinates(cCor), doorsNumber(cDorNum)
    {
        delete doors;
        doors = cDoors;
    }

    void addDoor(Room * fRoom, Side fSide)
    {
        Door * bDoors = new Door[doorsNumber + 1];

        for(unsigned int i = 0; i < doorsNumber; i++)
            bDoors[i] = doors[i];

        bDoors[doorsNumber] = Door(fRoom, fSide);
        delete doors;
        doors = bDoors;
        doorsNumber++;
    }

    void setCoordinates(int x, int y)
    {
        coordinates = Vector2i(x, y);
    }

    ~Room()
    {
        delete doors;
    }
};

bool isPosFree(Room fRoomsArray[], unsigned int fArrayLength, Vector2i fCoordinates)
{
    for(int i = 0; i < fArrayLength; i++)
        if(fRoomsArray[i].coordinates.x == fCoordinates.x && fRoomsArray[i].coordinates.y == fCoordinates.y)
            return false;

    return true;
}

bool isDoorOnSide(Door fDoorArray[], unsigned int fDoorsNumber, Side fSide)
{
    for(int i = 0; i < fDoorsNumber; i++)
        if(fDoorArray[i].doorsSide == fSide)
            return true;

    return false;
}

SideVector checkNearby(Room fRoomsArray[], unsigned int fArrayLength, Room fRoom)
{
    SideVector sides;

    for(int i = 0; i < fArrayLength; i++)
    {
            if(!(isPosFree(fRoomsArray, fArrayLength, fRoom.coordinates + Vector2i( -1, 0))))
                sides.Up = true;

            if(!(isPosFree(fRoomsArray, fArrayLength, fRoom.coordinates + Vector2i(1, 0))))
                sides.Down = true;

            if(!(isPosFree(fRoomsArray, fArrayLength, fRoom.coordinates + Vector2i(0, 1))))
                sides.Right = true;

            if(!(isPosFree(fRoomsArray, fArrayLength, fRoom.coordinates + Vector2i(0, -1))))
                sides.Left = true;

        return sides;
    }
}

bool isNotColliding(Room fRoomsArray[], unsigned int fArrayLength, Vector2i cCor, Side exSide)
{
    bool Colliding = false;

    for(int i = 0; i < fArrayLength; i++)
    {
        if(exSide != Side::Up)
            if(!(isPosFree(fRoomsArray, fArrayLength, cCor + Vector2i(0, -1))))
                Colliding = true;

        if(exSide != Side::Down)
            if(!(isPosFree(fRoomsArray, fArrayLength, cCor + Vector2i(0, 1))))
                Colliding = true;

        if(exSide != Side::Right)
            if(!(isPosFree(fRoomsArray, fArrayLength, cCor + Vector2i(1, 0))))
                Colliding = true;

        if(exSide != Side::Left)
            if(!(isPosFree(fRoomsArray, fArrayLength, cCor + Vector2i(-1, 0))))
                Colliding = true;

        return Colliding;
    }
}

#endif // ROOM_H_INCLUDED

//PLIK DRZWI
#ifndef DOOR_H_INCLUDED
#define DOOR_H_INCLUDED

#include "Room.h"
#include "SC.h"

class Room;

class Door
{
public:
    Room * goalRoom;
    Side doorsSide;

    Door(Room * cGoalRoom, Side cDoorsSide) :goalRoom(cGoalRoom), doorsSide(cDoorsSide) {}
    Door() {}

    Room * getGoalRoom()
    {
        return goalRoom;
    }

    Room * getRoom()
    {
        return goalRoom;
    }
};

#endif // DOOR_H_INCLUDED

//KLASY I FUNKCJE POMOCNICZE
#ifndef SC_H_INCLUDED
#define SC_H_INCLUDED

#include "SfmlBase.h"
#include <ios>


enum Corner
{
    UR,
    UL,
    DR,
    DL,
};

enum Direction
{
    Left, Right, Up, Down
};

struct MovementDirection
{
    bool    Up = 0,
            Down = 0,
            Right = 0,
            Left = 0;
};

typedef Direction Side;
typedef MovementDirection SideVector;

std::ostream & operator<<(std::ostream & fStr, SideVector fVec)
{
    fStr << "Up = "     << std::boolalpha  << fVec.Up    << std::endl;
    fStr << "Down = "   << std::boolalpha  << fVec.Down  << std::endl;
    fStr << "Right = "  << std::boolalpha  << fVec.Right << std::endl;
    fStr << "Left = "   << std::boolalpha  << fVec.Left  << std::endl;
    return fStr;
}

std::ostream & operator <<(std::ostream & buffi, Vector2i coordinates)
{
    buffi << "(";
    buffi << coordinates.x;
    buffi << ", ";
    buffi << coordinates.y;
    buffi << ")";

    return buffi;
}

template<class type>
void delFirst(type ** tab, unsigned short length)
{
    type * newTab = new type[length - 1];
    newTab = *tab + 1;
    *tab = newTab;
}

template<class type>
void addNew(type ** tab, unsigned short length, type added)
{
    type * newTab = new type[length + 1];
    newTab = *tab;
    newTab[length] = added;
    *tab = newTab;
}

#endif // SC_H_INCLUDED

//krótki plik. trochę nie ma sensu
#ifndef SFMLBASE_H_INCLUDED
#define SFMLBASE_H_INCLUDED

#include <SFML/Graphics.hpp>
#include <iostream>

using namespace sf;

#endif

Problem jest taki, że gdy uruchamiam program samodzielnie zacina się po ok. 14 lub mniej rekurencjach w pliku z mapą, lecz kiedy uruchamiam go debuggerem to wtedy wykonuje się tyle razy ile sobie zażyczę, zwracając jedynie przy zamykaniu programu błąd "Segmentation fault". Jest to dla mnie co najmniej dziwne więc proszę o pomoc.

Segmentation fault - std::unordered_map

Fri, 06 Apr 2018 17:55:35 +0000

Cześć widziałem parę podobnych, tematów, lecz wydaje mi się że u mnie jest problem złej organizacji projektu.

Problem polega wyrzucenie wyjątka "Segmentation fault", w momencie usuwania textury,

Żeby nie zaciemniać:

int main(void)
{
    DisplayMenager &dispMngr = DisplayMenager::getInstance();
    dispMngr.startup({800, 600});
 (...)
    glfwTerminate();
    return 0;
}

Display menager jest singletonem (coś mi się wydaje że tutaj już pierwszy błąd popełniłem), robi startup operacji.

void DisplayMenager::startup(glm::vec2 wndSize)
{
    this->width = wndSize.x;
    this->height = wndSize.y;
    this->init();
    this->enableDebug();
    this->prepare();
}


void DisplayMenager::prepare()
{
    //SETUP THE BLENDING MODE r-(1-a) g-(1-a) b-(1-a)
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_BLEND);
    this->LoadResource();
}


void DisplayMenager::LoadResource()
{       
    std::shared_ptr<Shader> tempShader(new Shader("res/shaders/Basic.vert"));
    this->_rscMngr.Add<Shader>("BasicShader", tempShader);    
    std::shared_ptr<Texture> tempTexture(new Texture("res/point.png"));
    this->_rscMngr.Add<Texture>("point", tempTexture);  
}

Pole this->_rscMngr wyglada tak:

class DisplayMenager
{
  private:

    DisplayMenager();
    DisplayMenager(DisplayMenager const &);
    void operator=(DisplayMenager const &);

     ResourceMenager &_rscMngr=ResourceMenager::getInstance();

    (...)


  public:
    static DisplayMenager &getInstance()
    {
        static DisplayMenager instance;
        return instance;
    }
};

Sam ResourceMengaer również jest singletonem - zależało mi żeby mieć dostęp do wszystkich zasobów z każdego miejsca programu - tak wiem że nie jest to thread safe, ale na razie ni przychodzi mi nic innego do głowy, no może factory pattern ...

class ResourceMenager
{

private:
  std::unordered_map<std::string, std::shared_ptr<Shader>> Shaders;
  std::unordered_map<std::string, std::shared_ptr<Texture>> Textures;

  ResourceMenager() {}
  ResourceMenager(ResourceMenager const &) {}
  void operator=(ResourceMenager const &) {}

public:
  static ResourceMenager &getInstance()
  {
    static ResourceMenager instance;
    return instance;
  }
  ~ResourceMenager(){ 
  }
  template <typename T>
  void Add(const std::string &name, T &resource);

  template <typename T>
  void Add(const std::string &name, std::shared_ptr<T> resource);

  template <typename T>
  T getResource(const std::string &name);
};

oraz cześć cpp

template <>
void ResourceMenager::Add<Texture>(const std::string &name, std::shared_ptr<Texture> resource){
    this->Textures.emplace(name, resource);
}

Segmentation fault wchodzi przy wychodzeniu z programu, przy wywoływaniu (niejawnie) metody clear na unordered_map,

i prowadzi do

Texture::~Texture()
{
    glDeleteTextures(1, &(this->_RendererID));
}

Wygląda mi to na jakiś problem z wywłaszczaniem, bo gdy ResourceMenager jest w main() nic zlego sie nie dzieje.

Wszystko generowane w cmake , a kompilowane :

gcc (Rev1, Built by MSYS2 project) 7.3.0
Copyright (C) 2017 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Flagi:

add_definitions(-DGLEW_STATIC)
add_definitions(-D_WIN32=1)
add_definitions(-Dfpermissive)
add_definitions(-Dj8)

Pozdrawiam.

Segmentation fault SPOJ

Fri, 16 Mar 2018 17:01:19 +0000

Witam, po próbie dodania rozwiązania do SPOJ-a, wyskoczył mi błąd o nazwie "Segmentation fault". Byłby ktoś tak dobry i wytłumaczyłby mi co powinienem w kodzie zmienić/dopisać? Z góry dziękuję za odpowiedź, a poniżej kod ;)

#include <iostream>

using namespace std;
int a, suma, i;
int main() {
	int *tab = new int[i];
	suma = 0;
	for (i = 0; i > -1; i++)
	{
		cin >> a;
		tab[i] = suma;
		tab[i+1] = a;
		suma = tab[i] + tab[i+1];
		cout << suma << endl;
}

       delete[] tab;
	return 0;
}

Segmentation fault w gcc na linuksie, który nie występuje w eclipse na windowsie.

Sun, 03 Dec 2017 03:12:38 +0000

Witam, jako że to mój pierwszy post chciałbym pozdrowić wszystkich użytkowników forum :) Postanowiłem ostatnio przesiąść się na linuksa. Jako kompilatora używam gcc-7. Rozwiązywałem zadanie ze SPOJ'a Flamaster. Napisałem taki oto kod:

#include<stdio.h>

int main(){
    int a,b,c,n;
    char wyraz[200], wyraz2[200];
    scanf("%d", &n);
    for(int i=0; i<n; i++){
        scanf("%s", wyraz);
        a=b=c=0;
        while(wyraz[a]!='\n'){
            b=0;
            wyraz2[c]=wyraz[a];
            a++; c++;
            while(wyraz[a-1]==wyraz[a]){
                b++; a++;
            }
            if(b==1) {wyraz2[c]=wyraz[a-1]; c++;}
            else if(b>=2) {wyraz2[c]=b+'0'; c++;}
        }
        wyraz2[c]='\n';
        printf("%s", wyraz2);        
    }
    return 0;
}

Wiem, że zapis

wyraz2[c]=b+'0';

będzie działał tylko dla b z zakresu 0-9, ale większe numery zaimplementuje później. Szukałem błędu przez około 2 godziny, aż wysłałem kod koledze, który odesłał mi screena i powiedział, że u niego program działa bez problemu. Używa on Eclipse i Mingw. Nie wiem, czy powinienem używać innego kompilatora na linuksie? Czy popełniam gdzieś błąd?

OpenGL i SFML - segmentation fault.

Wed, 22 Mar 2017 10:08:08 +0000

Witam!

Napisałem program, który ma wyświetlić na ekranie biały trójkąt. Kompilator i linker nie wywala żadnych warningów ani errorów. Jednak po uruchomieniu program się wylewa (segmentation fault).

Oto mój kod:

#include <GL/glew.h>
#include <SFML/Window.hpp>
#include <SFML/OpenGL.hpp>
#include <stdlib.h>
#include <stdio.h>
#include <string>
#include <streambuf>
#include <fstream>

char* loadShaderFromFile(const std::string& filename);


int main(void)
{
    glewInit();

    sf::ContextSettings settings;
    settings.depthBits = 24;
    settings.stencilBits = 8;
    settings.antialiasingLevel = 4;
    settings.majorVersion = 3;
    settings.minorVersion = 2;

    // create the window
    sf::Window window(sf::VideoMode(800, 600), "OpenGL", sf::Style::Default, settings);
    window.setVerticalSyncEnabled(true);
    window.setActive(true);

    float vertices[] = {
     0.0f,  0.5f, // Vertex 1 (X, Y)
     0.5f, -0.5f, // Vertex 2 (X, Y)
    -0.5f, -0.5f  // Vertex 3 (X, Y)
    };

    GLuint vbo;
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    
    GLuint vertShader = glCreateShader(GL_VERTEX_SHADER);
    GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER);
    char* vertSource = loadShaderFromFile("vshader.vert");
    char* fragSource = loadShaderFromFile("fshader.frag");
    glShaderSource(vertShader, 1, &vertSource, NULL);
    glShaderSource(fragShader, 1, &fragSource, NULL);
    GLint status;
    glCompileShader(vertShader);
    glGetShaderiv(vertShader, GL_COMPILE_STATUS, &status);
    if(status!=GL_TRUE) 
    {
        puts("Shader compilation error!");
        return -1;
    }
    glCompileShader(fragShader);
    glGetShaderiv(fragShader, GL_COMPILE_STATUS, &status);
    if(status!=GL_TRUE) 
    {
        puts("Shader compilation error!");
        return -1;
    }

    GLuint shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertShader);
    glAttachShader(shaderProgram, fragShader);

    glBindFragDataLocation(shaderProgram, 0, "outColor");

    glLinkProgram(shaderProgram);
    glUseProgram(shaderProgram);

    GLint posAttrib = glGetAttribLocation(shaderProgram, "position");
    glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(posAttrib);

    GLuint vao;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);


    bool running = true;
    while (running)
    {
        
        sf::Event event;
        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed)
            {
                // end the program
                running = false;
            }
            else if (event.type == sf::Event::Resized)
            {
                // adjust the viewport when the window is resized
                glViewport(0, 0, event.size.width, event.size.height);
            }
        }

        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glDrawArrays(GL_TRIANGLES, 0, 3);

        window.display();
    }


    return 0;
}

char* loadShaderFromFile(const std::string& filename)
{
    std::ifstream file(filename);
    std::string str((std::istreambuf_iterator<char>(file)),
                 std::istreambuf_iterator<char>());
    return (char*)str.c_str();
}

Kompiluję na linuxsie Mint 18. Tu jeszcze mój Makefile:

CC=g++
CFLAGS= -std=c++11 -Wall -pedantic -g
LIBS= -lGLEW -lGLU -lGL -lsfml-graphics -lsfml-window -lsfml-system
OUTPUTFILE= out

all:
	$(CC) $(CFLAGS) main.cpp -o $(OUTPUTFILE) $(LIBS)

Z góry dziękuję za pomoc!

Usuwanie z listy, dlaczego "segmentation fault" ?

Sun, 12 Mar 2017 13:20:56 +0000

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

struct node
{
    int val;
    node *next;
};
void add(node* &H, int x) //dodawanie nowego węzła
{
    node *p = new node;
    p->val=x;
    p->next=H;
    H=p;
}
void del(node* &H) //usuwanie
{
    node *p= new node;
    H=p->next;
    delete p;
}
int main()
{
    node *H=NULL;
    add(H,8); // tutaj dodam sobie trzy węzły
    add(H,15);
    add(H,64);
    cout << H->val << endl; // elegancko wyświetla "64"
    del(H);
    cout << H->val << endl; // no i tutaj program się wysypuje ( żółta strzałka tutaj wskazuje ( Code Blocks ) )
    system("pause");
    return 0;
}

Witajcie

Nie rozumiem pewnego problemu. Otóż wszystko się elegancko kompiluje, ale wyskakuje mi naruszenie ochrony pamięci. Czemu tak? Przecież, podstawiam pod H następny element z listy ( jest to H = p-> next ) a następnie zwalniam pamięć poprzez "delete".

segmentation fault - problem z lokalizacją naruszenia pamięci

Thu, 16 Feb 2017 12:21:52 +0000

Witam. Jak w temacie mam problem ze zlokalizowaniem błędu segmentation fault. Wiem tylko tyle, że debugger zatrzymuje mi się w linii oznaczonej "►". Wrzuciłem tylko część kodu w której występuje błąd wszystko co potrzebne jest zawarte w tej części powyżej jest tylko ściągnięcie pewnych danych (część mało istotna nie sprawiająca problemu). Będę wdzięczny za każdą pomoc.

fstream dopis (nazwa.c_str(), ios_base::app);
        string nazwa_zakupionego;
        string cena;
        char pomoc;
        string tmp_str;                                     //tmp_str string powstający w celu zczytania interesujacej nas czesci ceny
        int cena_zl=0, cena_gr=0, dlugosc=0, j=0, tmp=0;    //tmp licba do funkcji atoi w celu zamiany stringa ceny na inta
        cout<<"Podaj nazwę zakupionego przedmiotu:\n";
        cin>>nazwa_zakupionego;
        cout<<"Podaj cenę:\n";
        cin>>cena;
        pomoc=cena[j];
        while (pomoc!='.'||pomoc!=',')
        {
            j++;
►           pomoc=cena[j];
        }
        tmp_str=cena[j+1]+cena[j+2];
        cena_gr = atoi(tmp_str.c_str());
        string tmp_string;
        while(tmp<j)
        {
            tmp_str=tmp_string+cena[j];
            tmp++;
        }
        cena_zl=atoi(tmp_string.c_str());
        dopis<<cena_zl<<"."<<cena_gr<<"\t"<<nazwa_zakupionego<<";"<<endl;
        dopis.close();

Segmentation fault przy wczytywaniu z pliku do tablicy

Fri, 27 Jan 2017 12:35:50 +0000

Cześć,

muszę stworzyć w C program do obróbki obrazów w formacie PGM, który będzie je odczytywał z pliku do tablicy i wykonywał na nich różne operacje. Napisałem wszystkie funkcje do obróbki i funkcje odczytu z pliku i zapisu. Program kompiluje się poprawnie, ale przy próbie wczytania obrazu, po podaniu nazwy, kończy się błędem "segmentation fault". Dodam, że kompilowałem za pomocą GCC na Linuksie.

Funkcja i wywołanie wczytania wyglądają tak:

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

#define MAX 512         // maksymalny rozmiar obrazu
#define DL_LINII 1024   // dlugosc buforow pomocniczych

// ODCZYT OBRAZU Z PLIKU DO TABLICY:
int czytaj (FILE *plik_wej, int obraz_pgm [][512], int *wymX, int *wymY, int *szarosci)
{
    char buff [DL_LINII];   // bufor pomocniczy
    int znak;               // zmienna pomocnicza
    int koniec;             // monitorowanie konca danych w pliku
    int i, j;

    // KONTROLA POPRAWNOSCI PLIKU:
    if (plik_wej == NULL)
    {
        fprintf (stderr, "Blad: podany plik jest nieprawidlowy!\n");
        return 0;
    }

    // "NUMER MAGICZNY":
    if (fgets (buff, DL_LINII, plik_wej) == NULL)   koniec = 1;     // wczytanie pierwsze linii z pliku
    if (buff [0] != 'P' || buff [1] != '2' || koniec)
    {
        fprintf (stderr, "Blad: podany plik nie jest plikiem PGM!\n");
        return 0;
    }

    // POMIJANIE KOMENTARZY:
    do {
        if ((znak = fgetc(plik_wej)) == '#')
        {
            if (fgets(buff, DL_LINII, plik_wej) == NULL)    koniec=1;
            else    ungetc(znak, plik_wej);
        }
    } while (znak == '#' && !koniec);

    // POBRANIE PARAMETROW OBRAZU:
    if (fscanf (plik_wej, "%d %d %d", wymX, wymY, szarosci) != 3)
    {
        fprintf (stderr, "Blad: Brak wymiarow obrazu lub liczby stopni szarosci\n");
        return(0);
    }

    // ZAPISANIE OBRAZU W TABLICY:
    for (i=0; i<*wymY; i++)
    {
        for (j=0; j<*wymX; j++)
        {
            if (fscanf(plik_wej, "%d " ,&(obraz_pgm [i][j])) != 1)
            {
                fprintf (stderr, "Blad: Niewlasciwe wymiary obrazu\n");
                return(0);
            }
        }
    }
    return *wymX * *wymY;
}

/************************************/

switch (Wybor)
    {
        // WCZYTANIE:
        case 1:     CzyWczytany = 0;
                    printf ("Podaj nazwe pliku: ");
                    scanf ("%s", &nazwa_wej);
                    printf ("%s", nazwa_wej);
                    plik = fopen (nazwa_wej, "r");
                    if (czytaj (plik, obraz, &wymX, &wymY, &szarosci) != 0);
                    printf ("Obraz wczytany pomyslnie\n");
                    CzyWczytany = 1;
                    fclose (plik);
                    break;

/**********************************/

A gdyby to nie wystarczyło, to tak wygląda cały program: http://pastebin.com/WHKGVe4i

Z góry wielkie dzięki za pomoc.