LINUX.ORG.RU

Segmentation fault (Core dumped)

 


0

3
#include <iostream>
#include <ctime>
#include <cstdlib>
#include <fstream>
#include <cassert>
#include <cctype>
#include <cmath>


using namespace std;

class massgen
{
	public:
		int size;
		int *arr;
		int rand_size;

		void massprint()
		{
			cout << "Введите размер массива: ";
			cin >> size;

			arr = new int [size];
			//int *arr = (int *) malloc(size);

			if (size >= 20) {
            cout << "Введите размер рандомизации массива: ";
            cin >> rand_size;

				if (rand_size == 0) {
					cout << "Размер рандомизации массива не может быть = 0";
					exit(false);
				}

				cout << "Сгенерированный неотсортированный массив: " << endl;
				for (int i = 0; i < size; i++) {
					arr[i] = rand() % rand_size;
					cout << arr[i] << " ";
				}
			}

			if (size >= 2 && size < 20)
			{
				rand_size = 1;
				for (int i = 0; i < size; i++) {
					cout << "arr[" << i << "] = ";
					cin >> arr[i];
				}
			}

			else if (size < 2)
			{
				cout << "Wrong massive size";
				rand_size = 3;
			}
		}

		void test()
		{
			if (size >= 2)
			{
				cout << endl << "=== Test Cases ===" << endl;
				assert(size > 0);
				assert(rand_size > 0);
				cout << "Тест кейсы сработали";
			}
		}

		void configprint()
		{
			if (size >= 2)
			{
				ofstream cfgwrite;
				cfgwrite.open("configure.txt");
				cfgwrite << "[massive_size] = " << size << endl;
				cfgwrite << "[rand_size] = " << rand_size;
				cfgwrite.close();
				cout << endl << "Данные записаны в конфигурационный файл";
			}
		}

		void massfile()
		{
			ofstream fout;
			fout.open("massive.txt");
			fout << "Массив: " << endl;
			for (int i = 0; i < size; ++i) {
				fout << arr[i] << " ";
			}
			fout.close();
			cout << endl
             << "Массив успешно записан в файл" << endl;
		}
};

class sorts:massgen
{
	public:
		double start;
		double end;
		double time1;
		double start2;
		double end2;
		double time2;

		void bubblesort()
		{
			cout << "==== Массив, сортированный методом пузырька ====" << endl;
			start = clock();

			int buff = 0;

			for (int i = 0; i < size - 1; i++)
			{
				for (int j = size - 1; j>i; j--)
				{
					if (arr[j] < arr[j-1])
					{
						buff = arr[j-1];
						arr[j-1] = arr[j];
						arr[j] = buff;
					}
				}
			}

			end = clock();
			time1 = (end - start) / CLOCKS_PER_SEC;

			// вывод массива

			ofstream bubblefile;
			bubblefile.open("bubble.txt");
			bubblefile << "Массив, отсортированный сортировкой Шелла:" << endl;
			for (int i = 0; i < size; i++) {
				cout << arr[i] << " ";
				bubblefile << arr[i] << " ";
			}
			bubblefile << endl
                  << "Время работы сортировки = " << time1 << " сек";

			cout << endl
             << "Сортированный массив выведен в файл bubble.txt";
		}

		void shellsort()
		{
			cout << endl << "==== Массив, сортированный методом Шелла ====" << endl;
			int i, j, step;
			int tmp;

			start2 = clock();

			for (step = size / 2; step > 0; step /= 2) {
				for (i = step; i < size; i++) {
					tmp = arr[i];
					for (j = i; j >= step; j -= step) {
						if (tmp < arr[j - step])
							arr[j] = arr[j - step];
						else
							break;
					}
					arr[j] = tmp;
				}
			}

			end2 = clock();
			time2 = (end2 - start2) / CLOCKS_PER_SEC;

			// вывод массива

			ofstream shellfile;
			shellfile.open("shell.txt");
			shellfile << "Массив, отсортированный сортировкой Шелла:" << endl;
			for (int i = 0; i < size; i++) {
				cout << arr[i] << " ";
				shellfile << arr[i] << " ";
			}
			shellfile << endl
                  << "Время работы сортировки = " << time2 << " сек";

			cout << endl
             << "Сортированный массив выведен в файл shell.txt";
		}

		void timeprint()
		{
			cout << endl << "Время работы пузырьковой сортировки = " << time1 << "сек." << endl;
			cout << endl << "Время работы сортировки Шелла = " << time2 << "сек." << endl;
		}
};

class remove1:massgen
{
	public:
		void delarr()
		{
			delete[] arr;
			cout << "Массив очищен";
		}
};

int main(int argc, char *argv[])
{
	massgen array;
	array.massprint();
	array.test();
	array.configprint();
	array.massfile();
	sorts print;
	print.bubblesort();
	print.shellsort();
	print.timeprint();
	remove1 call;
	call.delarr();
	return 0;
}

выдаёт ошибку «Segmentation fault (Core dumped)».

где допустил ошибку?

arr = new int [size];
//int *arr = (int *) malloc(size);
if (size >= 20) {
  cout << "Введите размер рандомизации массива: ";
  cin >> rand_size;
  if (rand_size == 0) {
    cout << "Размер рандомизации массива не может быть = 0";
    exit(false);
}

Дальше можно не читать

Deleted ()

Вот запустил бы под отладчиком и сразу увидел бы.

У тебя падает в методе print.bubblesort();. Т.к. инициализация массива пользовательским вводом происходит только в объекте array (метод massprint), а в объекте print у тебя пусто, а в поле size мусор.

ox55ff ★★ ()
else if (size < 2)
{
  cout << "Wrong massive size";

Если размер меньше двух, то имеем «неправильный массивный размер».

P.S. То, что ты хочешь сказать по английски называется «array».

KennyMinigun ★★★★★ ()
Последнее исправление: KennyMinigun (всего исправлений: 2)
  • gdb ./a.out core
  • (gdb) bt
    (gdb) frame номеркадра
    (gdb) print имяпеременной
    
    можно также написать просто info
  • Если мало отладочной инфы, то убрать оптимизацию в GCC, поставить -g3
Crocodoom ★★ ()

где допустил ошибку?

везде. Код - кровь из глаз и адская индусятина. Не используй сишные конструкции (массивы, rand(), clock(), и т.п.), когда пишешь на C++. return 0; в конце main не нужно. Да хотя бы просто форматирование поправь.

Компилируй с -g -fsanitize=address или undefined, тогда оно покажет тебе ошибку.

anonymous ()
Ответ на: комментарий от ox55ff

Лорчую этого господина.

int main(int argc, char *argv[])
{
...
  sorts print;
  [b]print.bubblesort();[/b]
...
}
void bubblesort()
{
...
  if ([b]arr[j][/b] < arr[j-1])
...
}

int *arr у тебя не инициализирован, т.е. указывает на мусор.

PS. научись пользоваться конструкторами и декструкторами, это серьезно упростит тебе жизнь

anonymous ()
Ответ на: комментарий от anonymous

Не используй сишные конструкции (массивы, rand(), clock(), и т.п.), когда пишешь на C++

кто запретил? хочешь - используй, хочешь - не используй. С++ это НЕ ООП. это просто набор разных инструментов под любые задачи. и с С он превосходно совместим.

я бы вот не рекомендовала использовать всякие там STL без особо резкой необходимости. они дико тормозят. а остальное - смотря насколько оно актуально для решения задачи.

Iron_Bug ★★★★ ()
Последнее исправление: Iron_Bug (всего исправлений: 1)
Ответ на: комментарий от Iron_Bug

всякие там STL без особо резкой необходимости. они дико тормозят.

Привет. А можно пример «диких тормозов STL»? А то мне STL нравится настолько, что у меня никогда она не тормозит.

azelipupenko ()
Ответ на: комментарий от azelipupenko

потестируй получше. сравни с ручными аллокаторами, например. вероятно, ты просто никогда не решал задач, которые действительно требуют нормальной производительности.

Iron_Bug ★★★★ ()
Ответ на: комментарий от Iron_Bug

потестируй получше. сравни с ручными аллокаторами. вероятно, ты просто никогда не решал задач, которые действительно требуют нормальной производительности.

а в чем проблема использовать кастомные аллокаторы в STL? Передаем нужный класс в параметрах шаблона, и все.

Я понимаю, что у эмбедщиков-байтофагов аллергия на все высокоуровневое (использовал вроде безобидную фичу языка, и дебажь потом неработающую прошивку как хочешь), но к производительности это мало относится. Например, в финтехе пишут только на крестах, а там каждая наносекунда на счету.

anonymous ()
Ответ на: комментарий от Iron_Bug

потестируй получше. сравни с ручными аллокаторами, например.

Понятно, что сотрясать воздух и прыгать в кусты всегда проще, чем давать аргументированные ответы. Но раз уж ты себя позиционируешь как опытного программиста, то приведи конкретные пример «диких тормозов» STL, чтобы твои заявления не были голословными.

Меня отсылать тестировать не надо. Ведь я то помалкиваю в данном случае и прошу лишь привести конкретный пример. Мне интересно просто, где же это STL проявляет свои «дикие тормоза».

вероятно, ты просто никогда не решал задач, которые действительно требуют нормальной производительности.

Вероятно, комитет по стандартизации цепепе тоже не решал подобных задач, поэтому и принял в состав языка STL. История и теория красивая, что тут сказать. Но чтобы это выяснить точно, приведи примеры задач, «которые действительно требуют нормальной производительности» и покажи, где STL проявит свои «дикие тормоза». Введи в курс дела, так сказать.

azelipupenko ()
Ответ на: комментарий от Iron_Bug

я бы вот не рекомендовала использовать всякие там STL без особо резкой необходимости. они дико тормозят. а остальное - смотря насколько оно актуально для решения задачи.

тут пора говорить «вон из профессии»

invy ★★★★★ ()
Ответ на: комментарий от Iron_Bug

потестируй получше. сравни с ручными аллокаторами, например. вероятно, ты просто никогда не решал задач, которые действительно требуют нормальной производительности.

cpu intensive ты имеешь в виду или что? Обычно задачи упираются в память, сеть и диск. Как поможет отсутствие STL в коде в случае последних трех вариантов как-то не понятно. Вот у меня в профайлере в топе висит сетевой стек и аллокатор памяти. CPU bound задачи лучше кластеризовать, ибо дрочка на Си приведет только к потере времени и дальнейшим костылям в архитектуре, которую все равно придется кластеризовать.

xpahos ★★★★★ ()
Ответ на: комментарий от Deleted

Сей господин, по-видимому, имел в виду повсеместное копирование в эпоху отсутствия move-семантики. В этом плане старые плюсы лагонутое дерьмо.

anonymous ()
Ответ на: комментарий от Iron_Bug

я бы вот не рекомендовала использовать всякие там STL без особо резкой необходимости. они дико тормозят. а остальное - смотря насколько оно актуально для решения задачи.

Обычно люди, которые так говорят, любят писать свои косо-кривые велосипеды на любой случай, которые работают медленнее и хуже, чем STL. Дешевле и проще их сразу посылать в известное место и к работе не допускать.

anonymous ()
Ответ на: комментарий от azelipupenko

Я могу попытаться ответить за опытного программиста насчёт тормозов STL.

Из тех «тормозов» STL, что я знаю: 1) В libc++ внутри std::sort обычный quicksort вместо introsort, от этого имеем худшую асимптотику O(N^2) вместо O(NlogN).

2) Снова про сортировку - тот же introsort можно было бы давно заменить на pdqsort, который показывает неплохой выигрыш в скорости (бенчмарки найдёте в Morwenn/cpp-sort на GitHub). Почему до сих пор не поменяли исплементации - хороший вопрос.

3) Касательно аллокаторов - странная предьява, конечно. Можно передать свой аллокатор, если уж на то пошло и есть необходимость в этом. Далеко не каждому программисту нужно таким заниматься.

4) Касательно производительности - в комитете тоже отнюдь не дураки сидят, и на производительность люди смотрят тоже. Так как заседатели в комитете - это представители различных крупных ИТ компаний, которые очень даже хотят инструмент для разработки производительных приложений.

zamazan4ik ★★ ()
Последнее исправление: zamazan4ik (всего исправлений: 1)
Ответ на: комментарий от zamazan4ik

все разговоры от «тормозах» нужно подкреплять тестами
задачу ТС вообще можно решать чем угодно и как угодно, но не так ужасно как это сделано )

x905 ★★★★★ ()
Ответ на: комментарий от anonymous

ну начнём с того, что std::sort в поставках libstdc++/libc++ не будет распараллеливаться. А для поддержки ExecutionPolicy можно реализовать отдельный алгоритм, который будет параллелиться. Не вижу проблемы.

zamazan4ik ★★ ()
Ответ на: комментарий от anonymous

Извините, не могли бы подсказать, почему был выбран именно qsort? я что-то не вижу информации, почему в libc++ используется именно qsort вместо introsort. Зато я знаю, что на это в libc++ баг заведён, и планируют сортировку заменить на Boost.Sort'овскую.

zamazan4ik ★★ ()
Ответ на: комментарий от zamazan4ik

Наверное у кого-то в мире есть операции CPU bound, поэтому и обращают внимание на эффективность генерируемого компилятором кода.

Скорее всего человек решает не ту задачу. Ну разве что это embedded, где действительно иногда нужно задумываться.

xpahos ★★★★★ ()
Ответ на: комментарий от anonymous

По ссылке ничего не сказано про сравнение с Introsort. Не понимаю, зачем вы мне эту ссылку кинули. Про сравнение с mergesort и heapsort мне не надо - мы не об этом говорим.

Зато у меня есть вот такие бенчмарки (делал не я) - http://warp.povusers.org/SortComparison/integers.html По этой ссылке наглядно видна разница на практике introsort и quicksort.

К тому же можно попросить бенчмарки у Морвенна, если он делал.

zamazan4ik ★★ ()
Ответ на: комментарий от zamazan4ik

facepalm Introsort это heapsort+-/quicksort и первая хуже ложится в кешлайн чем вторая
про О большое я и без графиков знаю, научитесь читать и понимать а не картинки рассматривать
https://www.glassdoor.com/Interview/So-as-we-see-Heap-Sort-has-better-worst-c...
садитесь, два, в яндекс вы не приняты

anonymous ()
Ответ на: комментарий от anonymous

Ну там ещё третья сортировка применяется, ну да это мелочи.

Порассуждать про кеши и я могу, чего уж там. Вы лучше покажите бенчмарки, где quicksort лучше introsort. Я в свою очередь бенчмарки выше привёл, показывающие обратное.

zamazan4ik ★★ ()
Ответ на: комментарий от zamazan4ik

Я могу попытаться ответить за опытного программиста насчёт тормозов STL.

Не трать напрасно своё время :-) Если уж дойти до паранойи овер 80-го левела и думать о «диких тормозах STL», о «жутких тормозах виртуальных функций», о «лютых тормозах new», о «просто невыносимых тормозах виртуальных деструкторов» (промахи кэша же, ага), ещё также можно вспомнить по std::vector<>::at() - там ведь проверка индекса, и поэтому тормоза просто нереальные - то можно составить целый доклад на очередную конференцию и выступить перед развешивающими ушки чайниками, поведав им про все эти ужасы «накладных расходов». Ну и если продолжать упарываться подобным недугом, где всегда мерещатся «тормоза в рантайме», необходимо забыть про все нынче существующие высокоуровневые языки. Финалом должно быть забвение цепепе, т.к. он часто тормозит в последнее время с этими вашими нововведениями, и есть вероятность превысить лимит «накладных расходов». Лол.

azelipupenko ()
Ответ на: комментарий от zamazan4ik

какая еще третья сортировка ? у вас какие то выдуманные алгоритмы ?
https://en.wikipedia.org/wiki/Introsort

Introsort or introspective sort is a hybrid sorting algorithm .... It begins with quicksort and switches to heapsort ...



ваши тесты покажут только то что на вашем железе с вашим окружением в данный момент
вы собираетесь сравнивать introsort который в самом начале алго запускает quicksort с quicksort-ом ?
это абсурд
вернитесь в началу вопроса, почему в большинстве стандартных алго был выбран quicksort
и изучите вопрос, ссылок у вас достаточно

anonymous ()
Ответ на: комментарий от azelipupenko

«просто невыносимых тормозах виртуальных деструкторов» (промахи кэша же, ага)

Это какой степенью криворукости нужно обладать, чтобы тормознутость виртуальных деструкторов имела значение?

anonymous ()
Ответ на: комментарий от anonymous

Читаем чуть ниже про имплементацию в libstdc++

The GNU Standard C++ library is similar: uses introsort with a maximum depth of 2×log2 n, followed by an insertion sort on partitions smaller than 16.[2]

Так что ничего не выдуманная у меня сортировка.

ваши тесты покажут только то что на вашем железе с вашим окружением в данный момент

Так покажите обратные тесты, чего же вы. Я показал, причём это не мои тесты. Если у вас другие тесты - прошу их показать, пожалуйста. А не просто сотрясать воздух.

Ах да - начнём сравнивать, где и в каких языках стандартной выбран просто quicksort, а где pdqsort, timsort, introsort и так далее?

zamazan4ik ★★ ()