Это копия, сохраненная 26 сентября 2015 года.
Скачать тред: только с превью, с превью и прикрепленными файлами.
Второй вариант может долго скачиваться. Файлы будут только в живых или недавно утонувших тредах. Подробнее
Если вам полезен архив М.Двача, пожертвуйте на оплату сервера.
Быть должен тот, кто вскоре прочитает
Тот код, что в этом треде был рожден!
Здесь черви, что к крестам любовь питают,
Чтят байтоебство мудрости венцом
И Бьерна откровениям внимают,
Вновь корчатся в терзанье вековом,
Узрев template error'ов рой несметный,
И снова компилятор мнят врагом,
Не зная, что все их мученья тщетны.
Литература:
Для нюфань:
Три классических учебника для начинающих. Все примерно одинаковой годноты, читать имеет смысл только какой-нибудь один, который больше приглянется.
Герберт Шилдт - C++. Базовый курс (2010) - http://goo.gl/qMLAFl
Роберт Лафоре - Объектно-ориентированное программирование в C++ (2004) - http://goo.gl/QvjR6x
Стивен Прата - Язык программирования C++ (2012) - https://goo.gl/z7kA8u
Для желающих сразу начинать с Откровений Создателя - классика (может показаться суховатым):
Бьерн Страуструп - Программирование. Принципы и практика использования C++ (2009) - https://goo.gl/87qXtW
Учимся не писать говнокод:
Книги про основные подводные камни для тех, кто осилил предыдущий пункт. Следует пролистать все.
Скотт Мейерс - Эффективное использование C++ (2005) - https://goo.gl/wsDXGz
Скотт Мейерс - Наиболее эффективное использование C++ (1996) - https://goo.gl/tHa0tO
Скотт Мейерс - Effective Modern C++ (на ангельском) (2015) - https://goo.gl/uImH0J
Скотт Мейерс - Эффективное использование STL (2002) - https://goo.gl/QtS8Dc
Герб Саттер и Андрей Александреску - Стандарты программирования на языке C++ (2005) - https://goo.gl/Cpk4YR
Наиболее детальные описания языка:
Бьерн Страуструп - Язык программирования C++ (2010) - https://goo.gl/iZBDiV
Стандарт C++14 (на ангельском) - https://github.com/cplusplus/draft/raw/master/papers/n4140.pdf
Последняя на данный момент версия черновика стандарта C++17 (на ангельском) - http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4527.pdf
Тонкости языка (для гурманов):
Андрей Александреску - Современное проектирование на C++ (2002) - https://goo.gl/e1V5BC
Герб Саттер - Решение сложных задач на C++ (2002) - https://goo.gl/iWaa6S
Герб Саттер - Новые сложные задачи на C++ (2004) - https://goo.gl/4nn512
Также для легкого чтения подойдет книжка c историей создания C++:
Бьерн Страуструп - Дизайн и эволюция C++ (1994) - https://goo.gl/FqbPwo
Отдельные аспекты:
Читать по необходимости.
Энтони Уильямс - Параллельное программирование на C++ в действии (2012) - https://goo.gl/qJfBkD
Николаи Джоссатис - C++. Стандартная библиотека (2012) - https://goo.gl/PEyiMH
Дэвид Вандевурд, Николаи Джоссатис - Шаблоны C++. Справочник разработчика (2003) - http://goo.gl/0M4NpG
Ссылки:
Годный блог, в котором все просто и понятно тян не нужны кококок борщ - http://alenacpp.blogspot.ru/
Краткие описания библиотечных функций и контейнеров - http://ru.cppreference.com/w/
Блог Герба Саттера (на ангельском) - http://herbsutter.com/
Блог Скотта Мейерса (на ангельском) - http://scottmeyers.blogspot.ru/
Куда писать код:
Под шиндошс удобно использовать IDE Microsoft™ Visual Studio®. Базовую версию (2015 Community) можно бесплатно скачать, следуя инструкциям с этой страницы: https://www.visualstudio.com/ru-ru/products/free-developer-offers-vs.aspx. Чтобы начать писать код, нужно запустить Visual Studio, кликнуть "Файл - Создать - Проект - Пустой проект", после создания кликнуть слева правой кнопкой мыши по пункту "Файлы исходного кода", выбрать "Добавить - Создать элемент - Файл C++". Свои хэллоуворлды писать в этот файл, в дальнейшем можно добавить другие файлы и хедеры. Чтобы скомпилировать и запустить проект, нужно нажать "Сборка - Собрать решение", а затем "Отладка - Запуск без отладки".
Под *nix, как правило, уже предустановлен компилятор gcc (если нет, используй sudo aptitude install gcc), так что достаточно сохранить хэллоуворлд, набранный в текстовом редакторе, и выполнить g++ helloworld.cpp и ./a.out. Но удобнее установить какую-нибудь IDE, например, Code::Blocks (sudo aptitude install codeblocks) и работать в ней.
Можно также не устанавливать ничего, а запускать свои хэллоуворлды на http://ideone.com, выбрав в левом нижнем углу язык C++14.
Памятка:
Вопросу по синтаксису идут на хуй.
Лабы идут на хуй.
"Как мне сделать Х на чистых крестах без библиотек" идут на хуй.
Все идут на хуй.
Хейтер сосет члены на пару со своей мамашей.
Тег [code] работает через жабаскрипт-костыль: https://github.com/ololoepepe/MakabaCode
Предыдущий: >>525225 (OP)
А можешь пояснить насчёт этого всего? Чем вообще лучше пользоваться для констант? #define, enum, const, constexpr? Что для чего?
Потому что ты открыл файл на запись, а не чтение.
constexpr и constexpr-методы для сложных инициализаций констант.
Спасибо. То есть получается, объект создаётся в конце хедера? Как я понял, в каждом файле будет свой статический объект, верно?
cout это обычная глобальная переменная класса ostream, которая инициализируется до первого обращения к ней. Берешь и создаешь свою такую же, сможешь обратиться к ней отовсюду, где она будет видна.
Если тебе принципиально "автоматическое создание", то тогда непонятно, где ты хочешь, чтобы находился созданный объект. Допустим, ты все сделал, подключил хэдер, как ты дальше получишь единственный автоматически созданный объект класса? Если ты хочешь не получать объект, а использовать только статические методы через A::f (), то тебе и не нужно создавать объект, просто делаешь все методы статическими. А нестатические ты энивей не сможешь так вызвать даже транзитом. Если ты хочешь получить откуда-то ссылку на объект, то воспользуйся паттерном синглтон. Грубо говоря, так:
[code lang="cpp"]
class TvoyaMamka
{
\tstatic std::unique_ptr <TvoyaMamka> instance_;
static std::once_flag flag_;
\t
\t//Основное содержимое класса
\t//Приватные конструкторы
\t
public:
virtual ~TvoyaMamka();
static TvoyaMamka & getInstance()
\t{
\t\tstd::call_once(flag_, []
\t\t{
instance_.reset ( std::make_unique <TvoyaMamka> ());
\t\t});
\t\treturn *instance_.get();
\t}
};
//...
//Получаем ссылку на объект-мамку.
//При первом вызове она будет создана, дальнейшие будут возвращать ссылку на уже созданную
TvoyaMamka & mamka = TvoyaMamka::getInstance ();
[/code]
cout это обычная глобальная переменная класса ostream, которая инициализируется до первого обращения к ней. Берешь и создаешь свою такую же, сможешь обратиться к ней отовсюду, где она будет видна.
Если тебе принципиально "автоматическое создание", то тогда непонятно, где ты хочешь, чтобы находился созданный объект. Допустим, ты все сделал, подключил хэдер, как ты дальше получишь единственный автоматически созданный объект класса? Если ты хочешь не получать объект, а использовать только статические методы через A::f (), то тебе и не нужно создавать объект, просто делаешь все методы статическими. А нестатические ты энивей не сможешь так вызвать даже транзитом. Если ты хочешь получить откуда-то ссылку на объект, то воспользуйся паттерном синглтон. Грубо говоря, так:
[code lang="cpp"]
class TvoyaMamka
{
\tstatic std::unique_ptr <TvoyaMamka> instance_;
static std::once_flag flag_;
\t
\t//Основное содержимое класса
\t//Приватные конструкторы
\t
public:
virtual ~TvoyaMamka();
static TvoyaMamka & getInstance()
\t{
\t\tstd::call_once(flag_, []
\t\t{
instance_.reset ( std::make_unique <TvoyaMamka> ());
\t\t});
\t\treturn *instance_.get();
\t}
};
//...
//Получаем ссылку на объект-мамку.
//При первом вызове она будет создана, дальнейшие будут возвращать ссылку на уже созданную
TvoyaMamka & mamka = TvoyaMamka::getInstance ();
[/code]
> Если ты хочешь не получать объект, а использовать только статические методы через A::f (), то тебе и не нужно создавать объект, просто делаешь все методы статическими.
Вообще, да, именно статические методы и хотел получить. Просто я почему-то подумал, что вообще без объектов к ним не получится обратиться.
Это какая-то дичь, лол. В каждой единице трансляции с таким хэдером будет создана новая копия init с вызовом конструктора. И единственным на всю программу x и y будет многократно присвоены одни и те же значения. Я не говорю уже о том, что если в одном из таких файлов кто-то после определния init попытается записать в x или y в глобальном контексте например, в конструкторе еще одного статического члена, то последствия будут ужасны.
Да.
9.4.2/3 "A static data member of literal type can be declared in the class definition with the constexpr specifier ... In both these cases, the member may appear in constant expressions".
Делается это затем, что "it must be immediately constructed or assigned a value", а для нестатического члена-переменной это может произойти только когда объект будет создаваться.
void foo ()
{
//...
{
//<- point A
int x = 1;
//<- point B
int y = 2;
//<- point C
}
//...
}
[/code]
Вопрос к гуру. С точки зрения языка, в точке A не определены ни x, ни y, в точке B определена только x, в точке C определены обе. С точки зрения машинного кода, будет ли в точке B в стеке уже находиться y? Проще говоря, все переменные блока пихаются в стек в начале блока, или по мере определения?
Тут не надо быть гуру, чтобы ответить.
[code lang=cpp]
{
int x = y; //Ошибка, потому что y еще не определена (ее нет в стеке)
int y = 1;
}
[/code]
Тогда как решать подобные проблемы:
[code lang="cpp"]
{
int x = 1;
//Код, который может бросить исключение
//int y = 2;
}
//Здесь при проходе исключения нужно очищать стек, в котором хуй знает сколько членов, если для них не выделяется место при входе в блок сразу для всех
[/code]
y без комментария, конечно же.
Хуй знает, что ты пытаешься сделать, но возможно тебе поможет: static_assert, assert, try catch.
Да дело не в проблемах, лол, я просто хочу понять, во что это все компилируется.
Алсо, сейчас посмотрел листинг, судя по всему, таки сразу в начале блока EBP сдвигается так, чтобы дать места всем переменным блока, а потом int x = 1 уже превращается в простое присваивание. Вот такое там:
[code]
; 3 : \tint x = 1;
0001e\tc7 45 f8 01 00
\t00 00\t\t mov\t DWORD PTR _x$[ebp], 1
[/code]
Нет. Будешь собирать окна.
Нет.
Стек сам очистится. Если тебе принципиально вызов деструкторов у всех объектов, то в начале скопа обьяви все. Потом уже твой код с исключением
Нет. Но переписывать потом сам будешь.
char foo[128];
локальной переменной или в качестве члена класса, эти 128 байт будут выделены в стеке?
Блядь, ну что за долбоебы на моей доске? Для локальных переменных гарантируется, что они будут выделены в автоматической памяти стеке, для статических - что в статической памяти сегменте данных, для динамически выделенных - в динамической памяти куче. Это регламентировано, листинги смотреть для этого не надо, маня.
И кстати, это официальный C++ или какие-то аддоны компилятора так разрешают делать?
Там же, где и не классы. То, где выделяется, не зависит от того, класс это или примитивный тип.
По Qt-у думаю это наверну >>531415, норм для старта?
С сайта кьюта скачай кьют криэйтор. И буст с сайта буста. Если тебе из буста нужны только хедер-онли библиотеки, то просто путь для инклюдов добавь. Если нет, то ебись.
Офф доки (одни из лучших в опенсоурсе) + примеры. Ну и вопросы, ответы на которые ты не нашел в доках, задавай здесь.
Сами классы как абстракция нигде не выделятся, да. Но их методы, как и другие объекты второго класса, будут в сегменте кода.
>>5315027
Методы в сегменте кода, а другие члены при объявлении объекта выделяются и с каждым объектом новые, а методы только однажды?
Он внутри блока объявлен, поэтому на стеке.
Длина в твоем случае не определяется во время исполнения, constexpr вообще не появляется в рантайме, а const появляется, но еще во время компиляции из нее будет выдрано значение в отдельную таблицу констант, которое станет статическим размером. Поэтому, например:
[code lang="cpp"]
const size_t length2 = 128;
const cast <size_t &> (length2) = 1;
int bar [length2]; //Создается массив длины 128
[/code]
Да. Методы и статические члены-данные однажды, только данные будут в сегменте данных, а методы в сегменте кода.
>а const появляется, но еще во время компиляции из нее будет выдрано значение в отдельную таблицу констант, которое станет статическим размером.
Я для того кроме констэкспра и сделал просто конст, чтобы спросить, мол что если там значение, которое во время компиляции неизвестно. Компилятор умный конечно смекнет, что оно таки известно, но по C++ стандарту такое либо разрешено, либо нет. И если да, то значит оно как-то на стеке выделяется и для значений, которые во время компиляции не узнать.
Константы тоже однажды или в каждом объекте свои? Сегмент данных это же статическая память? Если в классе использовать new/delete, то те члены класса будут в динамической? А если объекты с помощью new/delete создавать, то методы тоже в динамической? Чтобы ты всё тут не расписывал посоветуй статью на эту тему.
мимопроходил
Если там значение, которое компилятору неизвестно, то определение массива не скомпилируется. Стандартом определено понятие "константное выражение", которое может быть вычислено на этапе компиляции. Когда компилятор видит определение константы, он смотрит на ее инициализатор. Если там константное выражение, он запоминает его в таблицу констант и в дальнейшем имя этой константы тоже будет константным выражением. Если это константный параметр, который неизвестен, или инициализатор использует неконстантное выражение, то такого не произойдет. Когда ты пытаешься определить массив, в качестве размера допустимо только константное выражение, поэтому компилятор, видя внутри квадратных скобок имя константы, проверяет, является ли она константным выражением. Если да, то он уже знает ее значение, если нет - будет ошибка компиляции. Никакого определения размера в рантайме здесь быть не может. Это все, разумеется, по стандарту, но и расширения компиляторов такого не делают, ибо полностью бы поменялась концепция выделения памяти.
Константность не влияет на это. Статическая константа будет одна, а нестатическая для каждого. Сегмент данных это статическая память. Если создать объект класса в динамической памяти, то его члены-данные из которых объект и состоит будут в динамической. Если просто использовать new в методах класса, то на члены это никак не повлияет, все будет зависеть от того, как был создан объект класса. Методы всегда создаются единожды, в сегменте кода, независимо от того, как создан объект, потому что метод принадлежит не объекту, а всему классу.
http://en.cppreference.com/w/cpp/language/object
http://en.cppreference.com/w/cpp/language/storage_duration
Нихуя себе, и правда ведь. Никогда бы не подумал, что в C++ компилятор может разрешать компилировать штуку с одним объектом какого-то типа, но ругаться на другую штуку того же самого типа. Пиздец ебанутая хуйня. Лучше бы они вообще такие штуки запретили.
Суть тут в том, что изначально в языке не было способа указать компилятору, что сущность содержит в себе константное выражение. Поэтому использовались const, как наиболее близкие к этому, и выполнялись дополнительные проверки на "статичность" ее значения. А сейчас в языке есть constexpr, с который специально предназначен для того, чтобы декларировать "статичность". Так что используй constexpr, и тебя эта проблема не коснется. А запретить такое использование const нельзя из-за обратной совместимости, легаси-код ведь тоже должен работать как-то.
Ты можешь объявить factorial со спецификатором constexpr, очевидно же. Иначе как компилятор узнает, что можно выполнить его тело на этапе компиляции?
Ну звиняй, хлопец, бананьев нема. Посмотри книжки в оппосте, у которых год издания поновее.
Похож на сына Вассермана.
#include <iostream>
#include <cstdlib>
using namespace std;
int main ()
{
int nums [10];
int a,b,t;
int size;
size = 10;
for (t=0;t<size;t++) nums[t]=rand ();
cout << "Ishodnuq masiv:";
for (t=0;t<size;t++) cout << nums[t] << " " ;
cout << "\n";
for (a=1;a<size;a++)
for (b=size-1;b>=a;b--){
if (nums[b-1] > nums){
t=nums [b-1];
nums[b-1]=nums;
nums =t;
}
}
cout << "Otsortirovannuq massiv:";
for (t=0;t<size;t++) cout << nums[t] << " ";
getchar ();
return 0;
}
Например массив :24464, 5, 52464...852(9-ая ячейка), 41(10-ая ячейка).
Почему сравниваются 10-ая и 9 ячейка, если >(b=size-1;b>=a;b--) и > if (nums[b-1] > nums[b])?
И как повернуть начало процесса налево? Ну чтобы сравнивало 1-ую и 2-ую.
Или я что-то не так понимаю? Объясни, друг, что да как, пожалуйста, как если бы пятикласснику объяснял.
Спасибо
#include <iostream>
#include <cstdlib>
using namespace std;
int main ()
{
int nums [10];
int a,b,t;
int size;
size = 10;
for (t=0;t<size;t++) nums[t]=rand ();
cout << "Ishodnuq masiv:";
for (t=0;t<size;t++) cout << nums[t] << " " ;
cout << "\n";
for (a=1;a<size;a++)
for (b=size-1;b>=a;b--){
if (nums[b-1] > nums){
t=nums [b-1];
nums[b-1]=nums;
nums =t;
}
}
cout << "Otsortirovannuq massiv:";
for (t=0;t<size;t++) cout << nums[t] << " ";
getchar ();
return 0;
}
Например массив :24464, 5, 52464...852(9-ая ячейка), 41(10-ая ячейка).
Почему сравниваются 10-ая и 9 ячейка, если >(b=size-1;b>=a;b--) и > if (nums[b-1] > nums[b])?
И как повернуть начало процесса налево? Ну чтобы сравнивало 1-ую и 2-ую.
Или я что-то не так понимаю? Объясни, друг, что да как, пожалуйста, как если бы пятикласснику объяснял.
Спасибо
Почему не робит? Ебланы, делавшие майкрософтовский компилятор, еще не сделали поддержку C++11 или C++14?
У тебя в коде внешний цикл с единицы и первый элемент не будет отсортирован. Сравниваешь элемент массива с самим массивом, это вообще не скомпилируется.
Ии еще.
for (b=size-1;b>=a;b--){
if (nums[b-1] > nums){
t=nums [b-1];
nums[b-1]=nums;
nums =t;
}
}
>if (nums[b-1] > nums){
t=nums [b-1];
Почему b в этих строчках невозможно заменить на что-нибудь другое. Как и почему управляющая переменная подчиняет nums?
Если бы ты прочитал сообщение об ошибке, ты бы понял, что в constexpr-функциях нельзя использовать условные операторы. И исключения, кстати, тоже нельзя бросать.
Еблан, ты можешь свое говно нормально отформатировать и вставить внутри [code тега? У тебя же [b съедается вакабой, хуиная голова.
А не, это я еблан. Хотя вижуал студия тоже ебланская - сообщение об ошибке хуевое, подсвечивает использование функции в коде, а не то, что функция объявлена constexpr, но в ней запрещенные для constexpr конструкции.
for (b=size-1;b>=a;b--){
if (nums[ b-1] > nums[ b]){
t=nums [ b-1];
nums[ b-1]=nums;
nums[ b ] =t;
}
}
тест
заебца. так вот...
for (a=0;a<size;a++)
for (b=size-1;b>=a;b--){
if (nums[ b-1] > nums[ b]){
t=nums [ b-1];
nums[ b-1]=nums;
nums[ b ] =t;
}
}
Пофиксил. ОНО компилируется. Но вопрос остался. Хуле не 9 и 8 а 10 и 9 сравнивается?
бейте, не обоссыте
Потому что это шаблон, в них ошибки не обязаны диагностироваться компилятором по стандарту.
>for (a=0;a<size;a++)
for (b=size-1;b>=a;b--){
if (nums[ b-1] > nums[ b]){
t=nums [ b-1];
nums[ b-1]=nums[ b ] ;
nums[ b ] =t;
}
}
упс... теперь точно норм.
>в них ошибки не обязаны диагностироваться компилятором по стандарту
А что, другие ошибки обязаны? Можно пруф?
Это не отменяет того, что хуевую диагностику сделали.
В C++11 нельзя фактически ничего, кроме return. В C++14 наоборот, можно почти все, но пока это не все компиляторы поддерживают.
Я не буду читать твое говно, пока ты не сделаешь нормальное форматирование. Залей на пастебин, блядь, никакого уважения к анонам.
Вроде кланг поддерживает, и больше никто.
Простите, мастер Шифу.
Вот это говно, компилирующее и сортирующее: http://pastebin.ru/1Wsmm6wU
Теперь мне кто-нибудь скажет бля, что я понимаю не так или почему сравниваются 9 и 10 , а не 9 и 8, если b-1?
Мммммм? Ааааааа?
1.4/2. Случаи, когда диагностики не надо, помечаются как "no diagnostic required", например, ошибки шаблонов или нарушения one-definition-rule.
Ну и вот это:
>Почему b в этих строчках невозможно заменить на что-нибудь другое. Как и почему управляющая переменная подчиняет nums?
Неа, как только ты редактируешь код, все constexpr перевычисляются. Студия покажет просто вычисленные значения.
Пиздец, у нас в треде имеется c++ standard lawyer? Нахуй ты стандарт читаешь, ты что ебанутый? Страуструп, залогинься.
Ну а хуле, там все просто и понятно. На самом деле нет, но в дополнение к гуглу очень даже неплохо.
https://ideone.com/6WdceZ
Видимо, ты не понял о чем я, а я вот об этом https://akrzemi1.wordpress.com/2013/06/20/constexpr-function-is-not-const/
Студия действительно обсирается и показывает неправильный размер std::array у второй переменной.
for (b=size-1;b>=a;b--){
if (nums[c-1] > nums[c]){
t=nums [c-1];
nums[c-1]=nums[c];
nums[c] =t;
}
}
Это совсем глупость, чувствую, но я про такую замену.
Лол, но почему во втором случае выводится 1? Понятно, что там много извращений у тебя, но в итоге-то между foo и bar ничего не меняется, не?
Ну, у тебя c не инициализирована, должно вылезти предупреждение. В остальном - ты вполне можешь его использовать, это просто будет постоянный индекс, не зависящий от цикла.
Я только что понял, что не ту статью скинул
Вот та, которуя я хотел показать http://b.atch.se/posts/non-constant-constant-expressions/
Блять, почему в треде про С++ объясняют какую-то хуйню мудакам, а по интересной задаче никто ничего не говорит?
С heap sort?
https://ideone.com/0mEjOf
Значением каким, блядь? У тебя написано int c, в переменной из-за этого мусор. Ты пытаешься считать nums [0x0bf468], и все крашится.
Предположу, что sizeof(a) в той функции - это хуйня какая-то, а вовсе не размер твоего массива.
Потому что в C++ sizeof это конструкция, вычисляемая во время компиляции. А когда компилируется функция, как она может вычислиться? Из этого я сделал вывод, что раз этот код вообще компилируется, то sizeof там выдаст такой же результат, как sizeof(int*).
sizeof(a) = sizeof (int *). Ты копируешь только первый элемент, замени sizeof (a) на параметр size.
>Ты копируешь только первый элемент
Почему? На ideone указатель однобайтовый что ли? Не верю.
В assign передается указатель на начало массива и на начало плюс sizeof (int *)/sizeof (int) = 4/4 = 1.
А, ну ладно. Значит ли это, что там 32-битная архитектура? Ведь на 64-битной sizeof(int*) должен быть 8, не так ли?
Да, но если у тебя 64-битная ОСи пекарня, это не значит, что все будет компилироваться под нее автоматически. Это тот еще геморрой, поэтому если нет требований к производительности, обычно компилируют для 32-bit и работают в режим совместимости.
Товарищи, вот вы скажите, если я так застрял на пузырьке, это значит, что суждено мне томиться в темнице гуманитарных наук веки вечные?
Да ладно, не верю. По крайней мере про g++ и clang++ не верю.
Не знаю, я писал пузырек только на паскале, а на кресты вкатился, когда уже выроз из пузырьков.
Судя по всему, ты решил по какой-то неизвестной причине выучить первым языком программирования C++. Это конечно пушка и совсем хуевое решение, но если уж ты решил и какое-то время на это потратил, то ладно.
И нет, ничего это не значит. Судя по куче моих знакомых, очень многие в начале много тупят на таких вещах, которые любому программисту кажутся очевидными.
Хотя на самом деле я даже не уверен, насколько это хорошее или плохое решение, потому что многие считают C подходящим первым языком, потому что байтоеблю когда-нибудь изучить надо. А C++ Си в себя включает.
Это просто божественно, упоротый засранец сделал меня охуеть. Есть еще подобное?
Более странного и ебанутого, чем это, я не знаю. А так если подписаться на hackernews и reddit.com/r/cpp, то время от времени прикольные штуки попадаются.
Я загуглил. Смайлодрочеры всяко разных говнофорумов яро советовали С. Долго думать не стал.
А, ну если C, то это лучше. А то это вроде C++ тред, я о просто C и не подумал.
#define SIZE 40000
int seq[SIZE]
работает нормально, а программа с
#define SIZE 65000
int seq[SIZE]
крашится при запуске.
Крашится потому что стека не хватает. Максимальный диапазон зависит от компилятора, каким типом он считает числовые литералы.
> Максимальный диапазон зависит от компилятора, каким типом он считает числовые литералы
Имелось ввиду при такой реализации как у тебя (через дефайн).
Нет лимита. Индекс должен влезать в size_t, который обычно 2^32 = 4294967296, но если он не влезет, ты получишь ошибку компиляции. С точки зрения лимита памяти, стандарт это не регламентирует, ты можешь запустить на машине с 640 килобайт памяти которых должно хватить каждому, лол и покрашиться уже на паре десятков тысяч. Стандартом регламентировано, что в этом случае должно бросаться исключение out of memory, емнип.
Известно ли значение членов-переменных класса во время компиляции?
Известно ли значение х во время компиляции, при х = sqrt(2) ?
Как последовательно идущие: объекты его базовых классов есть нюансы, гугли empty base optimization, указатель на его vtable если есть хотя бы один виртуальный метод, его нестатические члены-данные, с возможными промежутками из-за выравнивания. Порядок может различаться, стандарт вроде бы это не оговаривает. Гарантируется, что данные-члены будут идти в порядке их объявления, возможно, есть еще какие-то гарантии для объектов базовых классов, хуй знает.
Значение переменных неизвестно, это же переменные, блядь, они устанавливаются конструктором.
sqrt не является частью языка, так что зависит от того, откуда ты ее взял. Если она объявлена constexpr, то будет известно, иначе нет.
> Значение переменных неизвестно, это же переменные, блядь, они устанавливаются конструктором.
Но они ведь инициализованы.
> sqrt не является частью языка, так что зависит от того, откуда ты ее взял. Если она объявлена constexpr, то будет известно, иначе нет.
То есть constexpr int x = f(y); не будет компилироваться, если f() не объявлена как constexpr функция?
>Но они ведь инициализованы.
Без разницы, инициализация членов класса всегда рассматривается не как потенциально константное выражение, а как нечто, что нужно тупо передать конструктору. Все, что ты пишешь после =, будет неявно скопировано в список инициализации конструктора A::A () : x { 1 } { ... }.
>То есть constexpr int x = f(y); не будет компилироваться
Именно так.
Тащемта факториал от нуля обычно доопределён равным 1. Логики в этом нет, но намного упрощает жизнь математика.
Да нет возможности его показать.
>Ты не можешь поймать сегфолт без разыменования.
Я врать что ли буду, лол? До оператора return работает отладочная печать. После вызова этой функции печать не работает. Сигфолт именно в ретерне, но с чего бы это ему?
Если ты не способен написать даже пузырёк, то ты безнадежен
А вот и неть. Под объект память еще давно выделялась динамическая. А эта функция поиска возвращает указатель на него и в этот момент сегфолтится.
template<typename karasique>
typename sclad<payload>::yoba* sclad<karasique>::get(karasique& a) {
...Ищем йобу ранее добавленную йобу, возвращаем укащатель на нашу йобу
return yoba_ptr;
}
Ну чому там происходит сегфолт?
Указатель это примитивный тип, никакие действия с ним, кроме разыменования некорректного, не могут покрашить программу. Если ты не разыменовываешь его например, возвращая ссылку вместо указателя, то крашится не из-за этого. Например, у тебя может быть исключение в деструкторе какого-то из локальных объектов, или еще что-то подобное.
Как йобы хранятся в карасике?
ошибка была в деструкторе одного из локальных объекетов функции. Спасибо большое.
Оператора [][] нет. Перегружаешь [], который вернет объект класса, для которого перегружен [], который вернет значение. Будешь писать tvoya_mamka [15] [1];
Непонял. tvoya_mamka [15] [1] обрабатывается как (tvoya_mamka [15])[1] кроме там случая нормального двумерного массива (который не массив указателей на массив).
Случай двухмерного массива это не массив указателей на массив, а несколько одномерных массивов подряд. int a [5][10]; a [1] - второй по порядку массив из десяти интов. a [1] [2] эквивалентно (a [1]) [2], т.е. третий элемент этого "подмассива".
Нет. Мне просто интересно стало когда спрашивали и тоже спросил. Так где искать литературу на русском?
мимопроходил
Нахуй это здесь спрашивать. Тред посвящен языку. Так же как и кто-то там выше пузырек пытался запилить, да нахуй спрашивать это в С++ треде, каким нахуй местом это касается языка?
А если тот анон со своим пузырьком захочет его переписать на питон, ему что, в питон тред блядь идти?
Пойди в /gd/, спизди идеи у тамошних Кириллов и сделай игру на Unreal Engine.
[code lang=cpp]
//DUNGEON.h
namespace dng{
struct Row;
class Dungeon {
public:
Dungeon(const int, const int);
~Dungeon();
Row operator[](const int);
private:
char operator()(const int, const int);
friend struct Row;
const int D_HEIGHT, D_WIDTH;
char dungeon;
};
struct Row {
Row(Dungeon& dungeon, const int y) : dungeon_(dungeon), y_(y){}
Dungeon dungeon_;
const int y_;
char operator[](const int col)
{
return dungeon_(y_, col);
}
};
}
//DUNGEON.cpp
Dungeon::Dungeon(const int height, const int width) : D_HEIGHT{height}, D_WIDTH{width}
{
char dungeon = new char[D_HEIGHT];
for (int i = 0; i < D_HEIGHT; i++)
dungeon[ i ] = new char[D_WIDTH];
for (int y = 0; y < D_HEIGHT; y++) {
for (int x = 0; x < D_WIDTH; x++) {
dungeon[y][x] = NOTHING;
}
}
}
char Dungeon::operator()(const int y, const int x)
{
return dungeon[y][x];
}
Row Dungeon::operator[](const int y)
{
return Row(this, y);
}
//MAIN.cpp
#include <fstream>
#include "Dungeon.h"
#include "Constants.h"
int main()
{
std::ofstream out("dungeon.txt");
if(out.fail()){
perror("dungeon.txt");
return 1;
}
dng::Dungeon dungeon(36,96);
for (int y = 0; y < 36; y++){
for (int x = 0; x < 96; x++){
out << dungeon[y][x];
}
out << "\n";
}
return 0;
}
//Ошибка при рантайме
// Error in `./a.out': munmap_chunk(): invalid pointer: 0x00007ffe3fb85000
[/code]
[code lang=cpp]
//DUNGEON.h
namespace dng{
struct Row;
class Dungeon {
public:
Dungeon(const int, const int);
~Dungeon();
Row operator[](const int);
private:
char operator()(const int, const int);
friend struct Row;
const int D_HEIGHT, D_WIDTH;
char dungeon;
};
struct Row {
Row(Dungeon& dungeon, const int y) : dungeon_(dungeon), y_(y){}
Dungeon dungeon_;
const int y_;
char operator[](const int col)
{
return dungeon_(y_, col);
}
};
}
//DUNGEON.cpp
Dungeon::Dungeon(const int height, const int width) : D_HEIGHT{height}, D_WIDTH{width}
{
char dungeon = new char[D_HEIGHT];
for (int i = 0; i < D_HEIGHT; i++)
dungeon[ i ] = new char[D_WIDTH];
for (int y = 0; y < D_HEIGHT; y++) {
for (int x = 0; x < D_WIDTH; x++) {
dungeon[y][x] = NOTHING;
}
}
}
char Dungeon::operator()(const int y, const int x)
{
return dungeon[y][x];
}
Row Dungeon::operator[](const int y)
{
return Row(this, y);
}
//MAIN.cpp
#include <fstream>
#include "Dungeon.h"
#include "Constants.h"
int main()
{
std::ofstream out("dungeon.txt");
if(out.fail()){
perror("dungeon.txt");
return 1;
}
dng::Dungeon dungeon(36,96);
for (int y = 0; y < 36; y++){
for (int x = 0; x < 96; x++){
out << dungeon[y][x];
}
out << "\n";
}
return 0;
}
//Ошибка при рантайме
// Error in `./a.out': munmap_chunk(): invalid pointer: 0x00007ffe3fb85000
[/code]
Есть нормальные высокоуровневые библиотеки для клиент-серверной работы. Casablanca, например, или libcurl старое проверенное говно мамонта. Только средствами языка ты заебешься делать что-то, кроме своего пинг-понга.
Ок, вот запускаемая версия с нормальной разметкой
http://code.runnable.com/VdMajRA5sdkMVhvt/dungeon_generator-for-c%2B%2B
> не понимаю как это работает.
Для начала нужно почитать о модели OSI, об целях третьего и четвёртого подуровня и об устройстве протоколов IP, TCP и UDP. А после этого не заморачиваться и использовать библиотечные обёртки системных функций.
Как-то плохо тупо писать в Dungeon.hpp в конструкторе только типы аргументов, без названий - ведь хедер это как бы интерфейс, и должно быть понятно, что оно делает.
А еще если ты берешь в качестве аргументов int копию, то нет никакого смысла делать const - const нужен если по ссылке, а так эти инты в любом случае копируются.
А еще спасибо, что спалил мне такой классный сайт. Буду им пользоваться теперь.
Догадка, что у тебя может быть не так.
Ты уверен, что
char dungeon = new char*[D_HEIGHT];
создает то, что ты думаешь? Я просто плохо си знаю и не помню, как там работают все эти звездочки и скобки квадратные, когда их много. Если ты уверен, то ок. А если нет, то загугли и перепроверь, то ли там выделяется, что тебе нужно. И в деструкторе проверь, так ли delete[] работает, как ты думаешь.
Кстати, почему std::array или std::vector не хочешь использовать?
Ну и создай новый main.cpp и посмотри просто, будет ли у тебя вылетать оно, если создать экземпляр твоего класса, разименовать каждый указатель в этом dungeon, и выйти. Без работы с файлом. И посмотри, когда вылетает - в констркуторе, в деструкторе или при разименовании.
>А еще если ты берешь в качестве аргументов int копию, то нет никакого смысла делать const - const нужен если по ссылке, а так эти инты в любом случае копируются.
Я просто тестил кое-что и теперь лень убирать.
> еще спасибо, что спалил мне такой классный сайт. Буду им пользоваться теперь.
Не за что.
Какой же ты мудак, блядь. Я минут десять втыкал в твой код, пока не понял, что ты в конструкторе выделяешь в локальную переменную dungeon вместо члена класса. Ой дурак, пиздос.
БЛЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯДЬ.
ПИЗДЕЕЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦЦ
спасибо тебе, добрый анон.
Вот чтобы не было такой хуйни, делай всегда имена приватных членов с суффиксом_.
В одном из предыдущих тредов обсуждалась замена Таненбауму, книжка по лекциям Машечкина. Ссылка тоже была там. Но вообще я бы на твоем месте попробовал Таненбаума, читается легко и интересно.
Тогда спасибо. Скачаю почитаю.
>free
>free!
>License: 30 day trial
>This license has expired
На SO советуют запускать с RunAsDate лол. Или регать мс акк, давать студии доступ к инету, логиниться, ставить себе анальные зонды. Ну охуеть теперь.
free, блять.
В чем проблема-то, лол? Я вот с dreamspark поставил enterprice edition, брат жив, зависимость лютая.
Любой, который ставит хук на сетевые функции и хер что сделаешь, будучи серьезным приложением.
Например, Outpost. Или ты намекаешь, что и в нем могут быть анальные зонды, спонсируемые майкрософтом? Несереьзно, за столько лет уже спалились бы. Прокси + вайршарк, или что там сейчас юзают. Спалились бы == вой жуткий поднялся бы == потеря тысяч клиентов == банкротство. Нереально. Ну и как бы не Outpost-ом единым, есть и другие варианты.
А когда оказалось, что десятка шлет запись с вебкамеры, поднялся вой, ммм? Всем похуй, пора бы привыкнуть.
Даже объяснять лень.
> сетевые функции
Сетевые функции контролируются системой производства майскрософт. Если твой фаервол живет в среде операционной системы виндоуз то абсолятно вся информация которую он получает выдается ему системой (тоесть находится под контролем майкрософта). И если майкросфт захочет передать какую-то информацию фаервол (живущий в системе) никак помешать не сможет в принципе, он даже его не заметит. Шанс защищиться есть только снаружи, тоесть пытатся контролировать и анализировать исходящий трафик с помощью другой промежуточной машины, желательно с открытым ПО (как вариант виртуализация).
Ты не замечаешь внешнего сходства Мавроди и Била? Да они же двоюродные братья.
Ну как бы да. Все адекватные айтишники послали десятку нахуй и решили, что после конца семерки переберуться на линукс.
>>532196
Верно пишешь. И выводы верные - любой скрипткиддис может посмотреть, наебывает ли нас майкрософт (обходит ли файрволл на уровне ядра) - с помощью всего лишь одной машины. Как только при включенном "mode: block all" пойдет траффик, значит, наебывает. Но за последние 8 лет такого никто не замечал, всё работает, клиенты довольны.
Посоны, а вдруг Visual C++ тоже незаметно во все компилируемые программы вставляет код, который отправляет на серверы весь std::cin?
Нет. Люди бы заметили. Куча реверс инженеров проверяют ассемблерный код и всё такое.
Когда ты компилируешь под винду, то у тебя и дизассемблер проприетарный под виндой. И он может намеренно скрывать этот код, ну или винда видит запущенный дизассемблер и подменяет код для анализа.
Под вайном программы работают. Значит никакой подмены нет.
Не. Он просто вставляет аналоги Sleep(1) в кучу разных мест, чтоб юзеры делали апгрейды.
и почти не шучу же. В какие-то большие продукты точно помню кто-то такое засовывал
Хардварные файерволлы наше все.
XXXDDDD))
IDA разбирает бинарник вне зависимости от оси на которой установлена. Ос ей нужна только для дебага по удалёнке
>Чему равен индекс 3 элемента вектора
Почему просто взять и не спросить про начальный индекс любого массива? Нужно какую-то хуитень инопланетную спрашиать. Все через жопу и язык такой же черезжопный.
> Почему просто взять и не спросить про начальный индекс любого массива?
Это более очевидно, ньюфаг может и вспомнить. А так может запутатся, обосрется с ответом - появится шанс что запомнит.
Ну например там есть ебланские вопросы "что такое вычисления?". А вообще я не знаю, что ты делаешь не так. Может ты пытаешься как на экзамене ответить, не гугля? Используй всю доступную информацию.
Ну, я гуглю, но некоторые вопросы или термины даже гугол не знает и их в книге не нашёл. Например:
<<
#include
библиотека
вывод
компилятор
вычисления
и т.д.
Может я что и знаю, но что на эти термины писать - я не понимаю. Я себе отдельый файл завёл в ворде для них.
Лол. Если ты книгу читал, то тебе должны были про это что-то говорить, нет?
>вычисления
Это вроде обычное слово. Что непонятного?
<< - оператор такой
В C это побитовый сдвиг не помню в какую сторону. В C++ операторы можно перегружать, поэтому есть всякие stream'ы типа cout, с которыми он используется.
#include - вставить текст из другого текстового файла в этот при компиляции
библиотека - то, во что компилируется код, кроме запускаемого файла / просто нечто, что можно подключать к своему программерскому проекту и использовать оттуда всякие функции, классы и прочий код
вывод - ну типа то, что программа печатает, например через cout или printf
компилятор - программа, которая текстовые файлы с кодом превращает в бинарные файлы, с которыми может работать компьютер, у тебя это скорее всего g++, clang++ или майкрософтовский компилятор, встроенный в вижуал студию
И кстати это все еще ты, тот, кому на рандомном форуме посоветовали C первым языком?
>И кстати это все еще ты, тот, кому на рандомном форуме посоветовали C первым языком?
Нет, но я тут частенько спрашивал и приводил код.
Помню, мне кто-то с локалом, стд и консолью помог в треде.
Страуструп для новчиков хуево пишет. Попробуй другую книгу. А когда наберешься опыта и знаний, можешь начать читать Страуструпа "for mastery".
На вопросы страуструпа отвечать не надо. Там достаточно что ты сам понимаешь что такое вычисление и компилятор. И когда он попросит Переписать калькулятор только чтобы перегрузить оператор тебе этого делать не обязательно т.к. до этого он ещё раз 5 даст такое же задание только другими словами опишет и размер исходного кода решения будет меньше.
Вообще, стоит ли делать задания, которые я в уме решил?
Просто, тут есть задание, которое делать и придумывать долго, но я его, как бы, в уме решил на ++.
Нет. Но он задают много заданий на одну тему. Реши только одно в программе иди дальше.
>Просто, тут есть задание, которое делать и придумывать долго, но я его, как бы, в уме решил на ++.
Total manyamiroque.
Попробуй сделай теперь это задание от корки до корки в коде, и ты увидишь, насколько твоё "решение в уме" далеко от рабочего решения. По крайней мере, у меня так было, я делал все упражнения до единого (кроме одного в седьмом кажется параграфе, я так и не понял, чего он от меня хочет в той задаче).
Я, просто, сегодня целый день думал над задачкой Страуструпа, 5 тетрадных листов исписал всякими логическими выводами, а в конце взял и решил спокойно. Вроде правильно (задачка по угадыванию числа от 1 до 100): https://bpaste.net/show/7585607f3462
Я сначала хотел отсеивать по ифам и вопросам, типа меньше 50, чётное / нечётное, но понял что за 7 вопросов я это не сделаю и будет ОЧЕНЬ громоздким код, потом гугланул формулу Хартли и думал как сделать её цикличной. В итоге сделал, на ваш суд.
Я бы вместо "if/else-if/else-if/else" сделал лесенку с отступами вправо. Кол-во веток в лесенке чётное, пустые ветки содержат ";" и больше ничего.
[code lang=cpp]
if (check == 'y')
\t\t{
\t\t\tmax_value = div;
\t\t\tdiv = (max_value + min_value) / 2;
\t\t\tstd::cout << "Does the number less than " << div << "? " << std::endl;
\t\t\tstd::cin >> check;
\t\t}
\t\telse if (check == 'n')
\t\t{
\t\t\tmin_value = div;
\t\t\tdiv = (max_value + min_value) / 2;
\t\t\tstd::cout << "Does the number less than " << div << "? " << std::endl;
\t\t\tstd::cin >> check;
\t\t}
[/code]
Отличаются только 1 строчкой.
да.
Бля пиздец. Как же у меня с вас бомбит. Нахуя вы спамите своим говном в С++ треде. Блять, тред посвящен языку, и вопросом о языке. Создайте тред с алгоритмическими задачамитем более у тебя не задача а хуйня какая-то на 5 минут и решайте их там. Нет, ну серьезно, зачем просто постить здесь все подряд если у треда есть четкое направление?
>C++ тред
Действительно, какое же? Ну, как мне кажется, уместнее всего было бы задавать вопросы если не понимаешь какие-то механизмы абстракци языка, нюансы работы с памятью у этого языка, его библиотеки, и подобное.
Они оюсуждают алгоритм. Языком там что-то не пахнет.
Бородатая библиотека уровня WPF и ебля с VS2015.
Ну заебись, только название переменной max_value не отражает свою сущность, ведь оно там изначально 101, а 101 не может быть.
Типичная реакция зекачера на критику и пояснения. С таким подходом ты никогда не выучишь этот язык, тем более никогда не поучаствуешь ни в каком проекте, прибывая в забвении что если твоя лапша из циклов и условных операторов проходит пару тестиков придуманных тобой же, то значит что-то получается. Посылай нахуй когда тебе говорят вполне дельные и обоснованные вещи, еще пару месяцев попишешь хеловорлды и бросишь. Хотя если не бросишь это тебе же выйдет дороже, лол.
Я вообще не он, и я все давно уже выучил. А ты иди нахуй со своим "этот тред про язык C++, а не про программы, написанные на нем"
Ящитаю, вопросам непосредственно про язык должно уделяться большее внимание, чем алгоритмическим, но за неимением оных почему бы не подискутировать про алгоритмы на крестах? Кресты - язык многогранный, несколько тредов назад вон обсуждались ассемблерные детали, чтобы объяснить анону, как все работает под капотом. Это энивей интереснее, чем в десятый раз разжевывать долбоебам, где в памяти будет объект. Алсо, про алгоритмы на крестах есть неплохая книжка Седжвика, надо будет ее в шапку добавить.
>>532854
>>532850
И не надо ссориться, ребят. Даже самые опытные здесь все еще чему-то учатся. Треды для того и созданы.
Т.е. если бы я ввёл six / seven, то это было бы = 6 / 7.
В общем, я это реализовал, но как сделать так, чтобы если я ввёл сами 6 или 7 они бы определялись?
Хотя, я может задачу неправильно понял:
>Модифицируйте мини-калькулятор, описанный в упр. 5, так, чтобы он принимал на вход цифры, записанные в числовом или строковом формате.
Вот мини-калькулятор из упр. 5: https://bpaste.net/show/99f47bccd0f1 (сам сделал, довольно просто)
А другими методами никак, или логикой?
Просто, я такое еще не изучал и в книге не затрагивалась эта тема...
Ты, по-моему, умственно отсталый. Я помню эту задачу. У тебя число от 1 до 128 угадается не более чем за 7 попыток, т.к. log2(128) == 7.
Соответственно, для сотки алгоритм будет такой: есть минимальное число, есть максимальное. 6 раз берётся их полусумма и задаётся вопрос, больше ли это число. Далее меняется минимум (больше) или максимум (меньше) но полусумму.
Седьмой вопрос спрашивает, "это ли число?". Если да, овтет оно. Если нет, то ответ соседнее число.
Труп Страуса писал свою книгу основываясь на своих же лекциях, начисто упустив тот момент, что у студентов есть доп. литература, да и спросить у него можно. Поэтому либо менять книгу на попроще, либо страдать. Во втором случае если справишься, то научишься искать инфу в интернете и уровень знаний будет повыше. Но заебешься. Собственно советовать новичкам Страуструпа и Кнута для самостоятельного изучения это старый прикол, потому что они для этого слабо подходят.
Кстати с C без плюсов все наоборот - книга K&R была написана будто совсем для домохозяек, при том без воды. Всегда если у кого затыки в базовых вещах, советую её читать, хоть это и другой язык.
Правильно понимаю? Сначала b потом d или e порядок не определён, а потом c.
В каких ещё случаях есть неопределенный порядок выполнения?
Вычисление аргументов функций, все арифметические операторы.
Собственно, строгий порядок только у операторов && и || и ,
В с++11 что-то там подкорректировали, но не сильно.
Какая разница? Тебе моск больше нечем выебать?
Просто не пиши контекстно зависимые функций в одну строку и фсе.
Проще же писать выражения с функциями. Потом ещё одну переменную заводить не удобно.
Нет. Сложение это обычная функция - оператор, поэтому порядок между b и c тоже не определен. В твоем примере можно гарантировать только что d и e вычислятся раньше c.
Может быть, например, в порядке d b e c a. И такое реально бывает из-за оптимизаций компилятора.
Если вспомнишь, что в C++ есть operator+, а они не хотели бы, чтобы + вел себя по-разному для POD'ов и структур, то поймешь, что в этом отношении operator+ ведет себя так же, как любая другая функция.
Кого ты блять слушаешь? А если в b тебе скажут что твоя мать шлюха ты поверишь? Если не понимаешь нихуя читай Лафоре. Там все понятно.
выполняя код на стареньком eeepc 701 я обнаружил что время выполнения задачи всё время одинаковое-47сек(выводится самой программой), хотя секундомером мерил оно доходит до 1минуты 5 сек. И доходило до 1минуты 50 сек при двойном запуске той же самой проги, программа всё равно выводит 47секунд.Пробовал запускать на настольном пк там составило 7 сек, но не стал морочиться с загрузкой ядер-там их несколько. Может ошибка какая-то в коде?
float seconds;
clock_t sstart = clock();
unsigned long wait=0;
while(wait<4000000000)
wait++;
cout<<wait<<endl;
seconds=(clock()-sstart)/CLOCKS_PER_SEC;
cout<<"Время затраченное на складывание "<<wait<<"раз=";
cout<< seconds<<endl;
http://en.cppreference.com/w/c/chrono/clock
Returns the approximate processor time used by the process since the beginning of an implementation-defined era related to the program's execution. To convert result value to seconds, divide it by CLOCKS_PER_SEC.
Only the difference between two values returned by different calls to clock is meaningful, as the beginning of the clock era does not have to coincide with the start of the program. clock time may advance faster or slower than the wall clock, depending on the execution resources given to the program by the operating system. For example, if the CPU is shared by other processes, clock time may advance slower than wall clock. On the other hand, if the current process is multithreaded and more than one execution core is available, clock time may advance faster than wall clock.
Потому что Страуструп хуево пишет для новичков.
Перегрузка операторов повсеместно используется.
Про операторы он писал. А это как называется? Написано про это в главе про перегрузка операторов.
Тогда понятно. Тут и метод с конструкторами показали.
Читайте Эккеля, у него много описано того, что всякие Страуструпы забывают.
НА пике обычна перегрузка операторы вызова функции. Страуструп это не упускает.
Нет.
https://2ch.hk/b/res/100321630.html#100323740
Нет, не существует. Оставайся на своем пхп, питоджанге или чем вы там пользуетесь для веба.
Гугли CGI и его развитие. В хайлоаде часто встречаются вебсервисы на плюсах.
>Почему про него страуструп не говорил?
В очи долбитесь, уважаемый. Страуструп для ньюфань порядком много операторы перегружает.
Но про такой способ не рассказывал.
Глянул викижопию, по ней выходит, что просто для того, чтобы все время звездочки не хуярить.
Это не просто operator, это operator float
>>533471
Затем, что указатели были в C, а ссылок там не было. А потом страуструп придумал ссылки и сделал C++. И ссылки - они типа удобнее и безопаснее например потому что нельзя с ними арифметические операции проводить.
>>533472
Не знаю, что за билдер. Qt Creator - одна из лучших IDE под плюсы. На мой взгляд из линуксовых самая лучшая.
Билдер - дохлое говно, как и дэльфи.
Qt - котироваться будет на почти на любой вакансии C++ программиста.
Ну вот есть у тебя вектор большого размера, который был где-то там, существует где-то там, но в каком-то случае в нём надо петушнуть тройку-другую элементов, может прочесть, а может изменить. Копирование не вариант не только потому что он большой, но и потому что он изменён должен быть вне функции, а не создан. Передавая ссылку, ты работаешь с собственно сущностью, а не адресом.
Вот передашь ты указатель на вектор, и что он тебе, v.size() расскажет?
Не знаю. И знать (ПОКА ЧТО) особо не хочу, когда есть ссылки. Когда ссылки оверкилл, использую указатели.
Разыменование это унарная звездочка
Не обязательно проверять на делимость со всеми числами меньше этого - достаточно проверить на делимость на все числа, которые меньше или равны sqrt(это число)
Конструктор может инициализировать константу в списке инициализации (это то, что идет после двоеточия)
Каждый конструктор может своим значением её инициализировать? Можно константу при создании объекта сделать одной, а потом присвоить её другое значение вызвав другой конструктор?
Под винду котируют MS VS и QTcreator. Под никсами обычно всем похуй, хоть в консоль пиши.
В любом случае конструктор вызовется только один и только при создании объекта. Либо ты называешь конструктором что-то не являющееся конструктором, либо я не понимаю вопрос.
Он ничего не изменяет, а инициализирует ее. До того, как он вызовется, этой константы нет, она еще не существует и ничему не равна.
Понял. Спасибо.
Какого хуя, анон?
Где предположение что |z|<1 ?
Либо Кнут, либо переводчик обосрался, либо там до этого было что-то написано, что ты пропустил. Скорее второе.
>Затем, что указатели были в C, а ссылок там не было. А потом страуструп придумал ссылки и сделал C++. И ссылки - они типа удобнее и безопаснее например потому что нельзя с ними арифметические операции проводить.
>
Т.е., преимуществ указателей над ссылками нету?
Над указателями можно арифметические операции проводить.
>Где предположение что |z|<1 ?
Ещё один "умник". Это формальные ряды. Буква z, x и т.п. вводится чисто для удобства и не имеет никакого числового значения.
method1 - принимает в качестве аргумента константную ссылку на int.
method2 - принимает в качестве аргумента float по значению и не изменяет объект, у которого вызывается.
Хуй тебе через плечо.
>Кнут типа альфач, показывает что срал на математиков с их глупым формализмом.
У формальных степенных рядов нормально всё с формализмом. Кнут срал на зашоренных идиотов, у которых ряды == комплексные ряды.
>std::string filename{ 'd', 'a', 't', 'a' };
>std::ifstream ifs;
>ifs.rdbuf()->pubsetbuf(0, 0);
>ifs.open(filename, std::ios::binary);
>ifs.read(reinterpret_cast<char*>(current), streamsize);
Итак, мы прочли весь файл целиком и заполнили половину массива current. А теперь хотелось бы что-то типа "фигурного мемсета" -- чтобы заполнить вторую половину массива теми же самыми значениями. При этом, разумеется, не хотелось бы второй раз считывать данные с жёсткого диска.
Т.е. нужно скопировать первую половину массива в его вторую половину БЕЗ ЦИКЛА, т.е. максимально быстро. Как?
Ну если ты питаешь отвращение к new, то нет.
Без цикла никак, такие операции должна память на уровне железа поддерживать, почитай документацию к своей памяти, но врядли такое есть вообще. Подобные операции усложнят архитектуру железа, если сейчас каждая ячейка памяти соединена с шиной, то для таких операций её еще нужно соединить со всеми остальными, что дорого. Там скорее всего есть поблочное копирование, собственно в памяти GPU сразу блоками копируется, но это блок, если данные не влазят в блок то без цикла все равно не скопируешь. А в обычной памяти и того может не быть.
>ifs.rdbuf()->pubsetbuf(0, 0);
Зачем эта строка и зачем нули? То что это буфер я понял, а почему ты его убрал нет.
>ifs.read(reinterpret_cast<char*>(current), streamsize);
Тут reinterpret_cast зачем и почему используешь read?
Возможно, это то, для чего создаются всякие FreeRTOS. Дальше гугли сам, потому что я подробностей не знаю.
Есть где список что делают С++ программисты? Не список вакансия, а статистика в какой области работа.
Реалтайм системы - это системы с фиксированным временем отклика. Разруливает все это планировщик ОС. Прикладные программы должны корректно обрабатывать сигналы.
Теперь вопрос - где здесь с/с++?
>Теперь вопрос - где здесь с/с++?
Спросил чем на С++ занимается. Сказали что-то про реалтайм где высокая производительность нужна. Спросил тут что это. Чем обычн С++ программисты занимаются?
Тем же, чем и другие программисты - пишут код, решают проблемы, создают системы. Си и плюсы чуть ближе к железу, больше простор для оптимизаций, поэтому их используют там, где нужна скорость и компактность: встраиваемые системы, высокопроизводительные системы (веб сервера тоже).
>встраиваемые системы, высокопроизводительные системы (веб сервера тоже).
Ну вот веб сервер это наверно интересно. Где про это почитать? Может кто из работающих рассказать про свой последний проект?
За себя могу рассказать ещё: работал в компании, создающей софт для биржевой торговли - от краулеров биржевых данных, которые прям на самих биржах крутятся, до клиентских терминалов. Там такой хайлоад и тайм-критикал, что пиздец.
Сейчас работаю в компании-производители автомобильной (и не только) навигации - встраиваемые системы, девайсы, онлайн-сервисы. А в основе всего ядро на плюсах. Тут и мемори-критикал и тайм-критикал. А еще ограничения железа всякие.
Апач, нгикс, тысячи их.
>Где про это почитать?
В книжках Ричарда Стивенса об устройстве сетей и серверов (у него две или три книги).
>Может кто из работающих рассказать про свой последний проект?
Примерно как на картинке. Основной процесс вызывает функцию «fork()» и дальше они работают раздельно.
Нынешняя твоя работа наверно тоже интересная. Почитал про FreeRTOS и там вроде надо железо покупать. А я только 21 день учил С++ и хочу по инструкции сделать какой нибудь проект. Ради подобного баловство покупать железо не хочу. Есть какие нибудь симуляторы и инструкция как какой-нибудь простой проект с нуля?
>>533969
Какая книга?
http://www.books.ru/books/unix-razrabotka-setevykh-prilozhenii-82359/
http://www.bhv.ru/books/book.php?id=651
Где твой код потом будет?
Это не очень интересно выглядит. Хотел что низкоуровневое или связное с сетями. Но если не осилю, то можно и в Qt.
Поковыряй работу с устройствами - прямая работа с USB, например, - чтение и запись напрямую. Сделай из флешки токен авторизации. Под линукс - pam, под винду - логон менеджер.
Кто за какое время осилил данную книгу? И эффективно ли будет попутно второй язык изучать? Или нет смысла?
понятно, что в конце концов будет что-то вроде rep movs
Если кто-то проглотил эту книжку за несколько дней - тебе легче станет? Учишь ты, а не кто-то. У тебя свой темп.
Другой язык лучше не брать. Разве что си или асм.
Гугл нашел много коротких статей и 2 книги на английском. Что читать я так и не понял.
>memcpy
Похоже на то, что нужно. Единственный момент:
>нужно скопировать первую половину массива в его вторую половину
>If the objects overlap, the behavior is undefined.
Что здесь подразумевается под "перекрываются"? Да, это один и тот же массив, но две половины не перекрываются физически. Это подпадает под overlap?
это значит что ты копируешь область памяти в другую область памяти и эти области не пересекаются. Джае в твоем случае, ты разбиваешь массив на две непересекающиеся области.
Требование non-overlapped для производительности - нет доп проверок и лишних копирований во временную область.
Const у методов значит что этот метод можно вызывать даже если объект константный. А int& это ссылка, т.е. ты будешь менять ту переменную, которая передается как аргумент, а не ее копию.
>Требование non-overlapped для производительности - нет доп проверок и лишних копирований во временную область.
Спасибо, это я прекрасно понимаю сразу после прочтения en.cppreference. Но там не было уточнено, что такое overlap.
А можно пример копирования одной половины массива в другую половину того же массива? А то я с указателями не работал никогда (C++ мой первый язык). На моём же примере как это написать:
>std::string filename{ 'd', 'a', 't', 'a' };
>std::ifstream ifs;
>ifs.rdbuf()->pubsetbuf(0, 0);
>ifs.open(filename, std::ios::binary);
>ifs.read(reinterpret_cast<char*>(current), streamsize);
>далее везде @ вместо звёздочки из-за макабы
Напомню, что current имеет размер в байтах 2 X streamsize, но заполнен ровно на первую половину. Как теперь скопировать его первую половину во вторую половину?
std::memcpy(void@ dest, const void@ src, std::size_t count);
Т.е. как-то...
>std::memcpy(???, current, streamsize);
dest = src + размер данных
Если размер массива 100 байт то должно быть что-то типа, только проверь что тип src указатель на void или char, иначе там при суммировании скорее всего хуита получится
std::memcpy(src + 50, src, 50);
У меня uint16_t current размера 2 X streamsize (в байтах). То, что это массив short unsigned int (uint16_t), не критично для указателей memcpy? Вот я в этом не разбираюсь. То, что размер всего массива именно в БАЙТАХ мне точно известен как 2 X streamsize, я могу гарантировать. Тогда получается так:
std::memcpy(current + streamsize, current, streamsize);
или же мне нужно лепить какие-то там реинтепрет_касты в указатели на чар?
Проблема в арифметике указателей. В зависимости от типа current суммирование даст разные результаты. Ты должен посмотреть какого типа у тебя current (указатель на uint16_t), определить размер буфера в том типе указателем на который является current (если я правильно тебя понял это streamsize) и прибавить половину от размера буфера. Если current имеет тип указатель на uint16_t то прибавлять нужно streamsize/2 (если размер буфера выраженый в uint16_t является streamsize). Если current имеет тип указатель на void/char то прибавлять нужно streamsize (половина от размера буфера в байтах, который равен 2*streamsize). Если ошибок нет то кастить ничего не надо, будет неявное приведение. Для явности можно и добавить, но помоему это только читаемость ухудшит, вообще это внутрення реализация которая не должна наружу вылазить, если бы memcpy писали сейчас, то она скорее всего была бы шаблоном, а не принимала указaтели на void.
>Проблема в арифметике указателей.
Я вот их и не понимаю. Совсем. Далее я запутался. Я ещё раз повторю: У меня есть массив uint16_t current[n]. Его размер в байтах (именно в байтах) равен 2 X streamsize, причём данное значение не зависит от количества бит в байте (8 или 16). Я пишу кроссплатформенно. Т.е.
>std::streamsize streamsize = sizeof(uint16_t) * n / 2;
Где std::size_t n -- (обязательно чётное) количество элементов массива uint16_t current. Так как теперь будет выглядеть строчка
>std::memcpy(current + ???, current, ?);
если мне нужно первую половину массива uint16_t current скопировать в его вторую половину?
Без понятия, как там осуществляется сложение указателей: сложение адресов байтов или положений конкретного элемента.
Для чара это будет совпадать, для остальных типов нет.
Запили свой код на ideone.com, чтобы понятно было, как у тебя работает, а анон тебе покажет, как в твоем случае вызывать memcpy.
Как дела сейчас на рынке вакансий в рашке и мире?
Судя по всему надвигается чудовищная жопа в мире по сравнению с которой 2008 год был бурей в стакане, а значит кто-то соснет.
Вангую, скоро вакансии в бодишопах будут на вес золота.
Вы недостаточно прочитали Ганса и Армадиллу.
В те времена доллар был дёшев, а рубль относительно дорог. Сейчас наоборот.
Поэтому ежели и случитьса жоппа, то другая.
Нахуй пошел, ок?
При |z| >= 1 в бесконечной сумме возникает undefined behavior поэтому на корректность утверждения всем насрать. Оптимизацию впервые увидел чтоли? Точно по той же причине, например, компилятор вправе проебать все твои проверки указателей на нуллы если ты до них пытаешься указатель разыменовать - на нулле это неопределенная операция, поэтому предполагается, что так не бывает.
Анус себе удали.
Оно-то будет, проблема в том, что раньше хотя бы от этого можно было съебать, а теперь ПРИДЕТСЯ ЭТО ТЕРПЕТЬ, потому что по всей видимости упадет спрос на программистов в мире в целом, а предложение на рынке труда только вырастет за счет выкинутых на улицу в период крузиса.
На внутреннем рынке работы тоже уже стало меньше, хотя мы дно еще даже не нащупали.
Крах дот-бума бодижопы как-то пережили, новых даже наплодилось.
Ссылку на что-то в куче ты можешь использовать в другом треде, например, а стек у каждого треда свой.
int a - будет в стеке, удалится при завершении scope'а, это быстрее, чем выделять память в куче
int* a = new int; - создастся в куче, это медленнее, потому что надо запрашивать память у операционной системы, не удалится при завершении scope'а, а удалится когда удалишь.
А если, например, есть цикл, а в нем есть "long a, b, c, d = 0;" и "double e, f, g, h, j, k = 0;", то что будет быстрее - выделить один раз перед циклом в оперативке, или каждую итерацию выделять в стеке? Я предполагаю, что компилятор может выделить один раз в стеке, а потом просто каждый раз сбрасывать значения, - этот вопрос скорее относится ко всяким функциям, которые едят входные данные и возвращают результат. Насколько дорого по скорости обходятся такие выделения, и стоит ли экономить на вспомогательных переменных в таких функциях?
Ну, если компилировать с каким нибудь -o2 -- ещё и не такое сделает. Нет, стёк будет быстрее даже если каждый раз выделять по новой. Нет, экономить на переменных не стоит, прироста ты не увидишь (если у тебя не будет овер 9000 раз выделятся по мегабайту в цикле). Выделять память в куче и передавать её по указателям стоит только тогда, когда объём информации = овердохуя. Даже чтобы передать какой нибудь long long куча себя не оправдает. А вот если например есть 5 мб текста - оправдает многократно.
Разница в том что стек фиксированного небольшого размера и очищается автоматически, плюс если от стековой переменной нигде не берется адрес то компилятор ее может в регистры запихать. Больше никакой.
>>534747
Ссылку на стек тоже можно передать, только надо сделать какой-нибудь лок чтобы он не уничтожился выходом из функции.
в первом случае еще нужно будет вручную удалить потом
http://www.mac-torrent-download.net/application/developer-tools/clion-1-0/
>>534312-кум
Как я понял - как бы глубоко он не был, он останавливает всегда весь цикл?
Т.е. например:
for ...
if
if
break - тут он останавливает (если сработает) 1 ступень цикла for как глубого в ифах он бы не был?
И что?
Да. Можно даже сказать, что это локальный return, если тебе так будет понятней.
Это не правда
Можно считать, что "выделять" что-то в стеке - вообще бесплатно, потому что на самом деле там ничего выделять не надо в отличие от динамической памяти, а надо всего лишь значение регистра изменить.
Да, break останавливает ближайший (наиболее вложенный) for/while/do/switch, на if и простые { блоки } не влияет.
Выделенная в куче память доступна на протяжении работы программы. Если ты выделяешь ее, например, внутри функции, и забываешь освободить, то ты допускаешь утечку памяти. Твоя программа начинает пожирать все больше и больше с каждым вызовом функции, пока система не начнет сбрасывать то, что не помещается, в файл подкачки. Частые выделения и освобождения произвольных кусков памяти разного размера приводят к быстрой фрагментации (Образуются дырки между выделенными участками памяти), что может замедлить работу программы.
Память, выделенная на стеке, "освобождается" с выходом из функции. Выделение памяти на стеке происходит гораздо быстрее выделения в куче. Стек по определению не подвержен фрагментации. Размер стека потока много меньше размера памяти доступной ОС, поэтому выделять на стеке в циклах не рекомендуется.
>Размер стека потока много меньше размера памяти доступной ОС, поэтому выделять на стеке в циклах не рекомендуется.
Что это вообще значит? Как ты можешь выделять все больше и больше памяти в стеке циклом, а не рекурсивной функцией?
Можно зделоть
https://msdn.microsoft.com/en-us/library/wb1s57t5.aspx
Ну он еблан явно и не поинмает, что пишет, но в теории это возможно
По-читерски, можно в цикле плодить threads, первым закончится именно стек.
По-читерски, можно в цикле плодить threads, первым закончится именно стек.
У тредов свои собственные стеки, а сегменты памяти могут расти. Поясни своё высказывание
У тредов свои собственные стеки, а сегменты памяти могут расти. Поясни своё высказывание
Все популярные конпеляторы/libc выделяют стек на процесс статически, плодя треды, ты это пространство быстро израсходуешь.
>Handle(Handle&& h) :p{h.p} { h.p=nullptr; }
g://c++ uniform initialization
В c++11 ввели uniform initialization
В Windows набор страниц для стека у каждого потока свой, размер выставляется явно, лимита на общий размер стеков всех потоков нет.
> Спасибо, это я прекрасно понимаю сразу после прочтения en.cppreference. Но там не было уточнено, что такое overlap.
Это когда ты берёшь первые 2/3 массива и копируешь их в последние 2/3 массива. Или вместо 2/3 берёшь полмассива с округлением вверх.
Спасибо. Уже забыл про эту главу.
Конкретно, хочу реализовать кучу, в которой бы в конструктор можно было передать функцию сравнения двух элементов.
Попробовал через указатель на функцию, но выглядит по-идиотски.
template <class T>
class MinHeap {
private:
bool (cmp)(T, T);
public:
MinHeap() {
}
MinHeap(bool (cmp_func)(T, T)) {
cmp = cmp_func;
}
};
для этого придумали наследование, интерфейсы, абстрактные классы. А ты продолжаешь работать в C-style
Наверняка ты хочешь сделать полную хуйню, которую не надо делать, но если все же надо, то принимай в конструкторе аргумент типа std::function, инициализируй им член и его и используй.
При попытке запустить debugging выдаёт "no debugger set up".
Дебаггер не идёт в комплекте с creator?
Можно ли задействовать debagger от visual studio?
Насколько я помню, в cygwin есть полностью все библиотеки юниксовые, то есть там есть даже реализация юникс форка под винду. В mingw насколько я знаю, этого нет.
А по названию предположу, что MinGW-64 - под архитектуру x86_64, а MinGW - наверное x86.
mingw - для разработки нативных приложений под винду, вроде как заброшен, а разработка продолжается в mingw-w64, который может не только в 32 бита, но и в 64. Cygwin - эмуляция позикса под виндой, типа как wine на лине работает, некоторые хардкорно линуксовые приложения могут поддерживать конпеляцию под cygwin, но не под mingw, т.к. разрабы срали на поддержку винды.
Дефолтным методом делаешь оператор сравнения.
Тебе какая-то конкретная книга нужна?
array_1 = (int@)std::malloc(array_size);
array_2 = (int@)std::malloc(array_size);
@ вместо *, как вы догадались. Далее, например, выполняем в цикле присваивание всех элементов array_1.
Вопрос. Что сделает инструкция:
array_2 = array_1;
?
тип array_1 и array_2 - int@? То есть это указатели на int? Если да, то присваивание делает так, что array_2 указывает туда же, куда и array_1.
Ну в Windows свои приколы, http://blogs.msdn.com/b/oldnewthing/archive/2005/07/29/444912.aspx
если 32 бита ещё кому-то интересны, конечно
> При попытке запустить debugging выдаёт "no debugger set up".
> Можно ли задействовать debagger от visual studio?
В настройках (внезапно) задается путь к дебаггеру, какой тебе нужен, раз сам не нашелся.
> Дебаггер не идёт в комплекте с creator?
Qt Creator это ide, всё. Кроссплатформенная причем, везде со своими дебаггерами. Впрочем, под виндой, насколько помню, можно в комплекте с MinGW накатить, там тебе все мокрописьки из коробки будут.
Мне пришлось windows sdk tools скачать. У меня насколько я понял не mingw, а msvc.
Поэтому написал свой аллокатор по типу pool. Я знаю, что в бусте есть то же самое, но мне было интересно научиться, к тому же, мой аллокатор в итоге работает чуть быстрее даже.
Для легкости встраивания в уже большую к тому времени программу, я создавал этот аллокатор как отдельный шаблонный класс со статическим пулом, статическими операторами new и delete (посмотрел - в инете так обычно и советуют), и, чтобы его использовать, достаточно просто наследовать от него нужные мне классы.
Например, так:
class Node : public FastpoolAllocator<Node>
И всё! Теперь, чтобы создать объект Node, можно это делать, как обычно: Node* node = new Node();
При этом, так как пул и все остальное статическое, сами объекты не вырастают в размерах, и имеют общий пул, который можно очистить, обратившись к соответствующему статическому методу аллокатора.
Однако обнаружил проблему. Эта моя программа - плагин для другой программы. И, если та программа создает две инстанции моего плагина, они обе будут использовать один и тот же пул для одного вида объектов. Логично, ведь пул же объявлен как статический.
Проблему можно решить, если создавать отдельный класс аллокатора и объект, и потом, обращаясь к этом объекту, выделять память. Но это неудобно, придется переписывать все текущие создания объектов, сделанные красиво, как new.
Может, есть какой-то другой способ, позволяющий сохранить синтаксис new и deleteб но привязывающий пулы к конкретным экземплярам плагина?
А, ну или еще можно передавать в доппараметрах к new и delete указатель на пул или сам аллокатор, это не так сильно меняет синтаксис, но всё-равно придется все выискивать.
Кстати, я заметил что мне проще решить задачку, расписывая её в тетради, а потом уже перенося в программу, а не сразу. Т.е. в тетради я сразу вижу ошибку, а в программе нет - значит я устарел или вы так же делаете?
Или, если не нравится семафор, есть ещё thread local memory, можно оставить указатель на пул в ней.
А оно правильно работает? А то ведь если ты в векторе делаешь erase, то его .size() изменяется
Работает правильно, я так и задумывал с удалением и изменением размера вектора.
Например: берётся число 2, удаляются все числа, которые делятся на 2 без остатка и вектор сокращается на это число. Потом берётся число 3, и проверяет деление уже оставшихся чисел - это суть решета Эрастофена.
Нет, проблема не в многопоточности. Это у меня в самом аллокаторе уже реализовано. Проблема в двух экземплярах одного плагина - обе они используют один и тот же пул, потому, что пул объявлен как static, чтобы быть общим для всех объектов класса, унаследованного от FastpoolAllocator. В рамках одного плагина это даже удобно.
Ты слишком обще и непонятно написал, так что могу сказать лишь что вызывать вручную деструктор - легально.
Делать так можно, но надо быть аккуратнее с дальнейшим использованием объекта. Такое применяется часто для синглтонов, когда некий статический метод уничтожает объект синглтона
Как правильно организовать самоуничтожение объекта? Как-то глупо, если за вызов деструктора для той-же бомбы отвечает внешняя среда.
> Как-то глупо, если за вызов деструктора для той-же бомбы отвечает внешняя среда.
Почему глупо? Это правильный подход когда тот кто создает объект его же и уничтожает. Это конечно же не всегда можно красиво сделать, например когда объект используют в нескольких других местах - в таких случаях лучше шаред поинтер навернуть, который и удалит объект когда он станет не нужен. А так как объекты сами не принимают решение о своем создании, делать так чтобы объект сам себя удалял нужно только когда это действительно упрощает программу.
for (int i = new int(0); i < 3; (*i)++)
Насколько это плохо и стоит ли бросать?
Сажа приклеилась
Надо работать с базой postgersql на vs15, что посоветуете?
new это долго
Эта хуйня нихуя работать не будет. Ты звёздочек забыл, долбоёб.
И да, сука, кипяти океаны бесполезными операциями.
Страуструп как раз-таки стандарт не читает, судя по его книге по C++11 для ньюфагов.
Чукча не читатель, чукча писатель. Вообще, последнее издание "языка C++" уже с учетом всех фишек C++11, но оно пока только на ангельском.
>>536531
Перетолстил, братюнь.
>>536535
Там память утекает, скорость это еще не самое страшное.
>>536492
Так они ведь и так "самоуничтожаются". Деструктор вызовется при выходе из области видимости автоматически, в случае кучи можно просто использовать unique_ptr, и будет тоже автоматически удаляться.
>>535910 >>535787
Ага. Тащемта, это я и написал выше, что стоит ее добавить.
>>535789
>2015
>malloc
>>535730
Они самые актуальные из существующих на русском, а в большинстве случаев и вообще только у нескольких русские издания отстают. Все старые книжки там не на тему синтаксиса, поэтому советы актуальны и сейчас почти все. Например, книги о шаблонах довольно старые, но лучше за десять лет ничего не написали, а большая часть информации осталась полезной, хотя с variadic templates многое стало можно сделать проще.
>>534786
Он, возможно, имел в виду регистровые буферы, регистровые окна и вот это все.
Если я наследуюсь от QObject и вставляю Q_OBJECT макрос, будут ли объекты моего класса автоматически удаляться?
new это встроенный оператор, он может быть реализован компилятором гораздо эффективнее, чем вызов malloc, который обязан передаваться ОС. Юзать пул, например, или использовать данные об объектах, для которых выделяется память, чтобы уменьшить фрагментацию и позволить данным лучше кэшироваться в результате.
Я уже не могу смотреть на переменные без приставок. Например int i; Ну что это такое? Вот понимаю - int *i; Да, это классно смотрится. Ещё есть какие-то reference. Расскажите про них?
[code]
QObject::connect(view, SIGNAL(loadFinished(bool)), slot_wrapper, SLOT(callback(bool)));
[/code]
Можно ли его вызывать с лямбдой вместо обертки над слотом? Как передать в колбэк сам QWebView *view, к которому аттачим листенер?
Объект в крестах удаляется только тогда, когда ты вызываешь delete, либо когда он выходит из скоупа (впрочем, во втором случае опять же неявно вызывается delete). Для указателя это тоже верно: сам указатель удаляется. А вот объект, на который он указывает - нет. В Qt нет никаких специальных GC или чего-то подобного, так что все сводится к вызову delete и выходу из скоупа. Пллюс еще, если у объекта есть родитель, то при удалении родителя будет удален и этот объект (и все другие дочерние объекты).
> сделал орфографическую ошибку
> я всё правильно написал а ты ньюфаг и не понимаешь глубокого смысла
Хэдеры лежат в "путь_к_папке_с_программой\VC\include", причем у стандартных нет расширения, поэтому придется добавить .h. cpp файлов вообще нигде нет, как и объектников, соответствующих единственному хэдеру. Те объектники, из которых все собирается, лежат в "путь_к_папке_с_программой\VC\bin", но там хер проссышь, какие именно линковать вручную, а для подмены с другим компилятором вряд ли подойдут, ибо внутренние форматы зело разные.
Советую не париться с либами и другим компилятором, а накатить отдельно Visual C++ как когда игоры устанавливаешь, можно будет компилировать из консольки.
Кодблокс сам у тебя спросит какой компилятор использовать если хочешь сменить IDE но оставить компилятор.
Детка, это /pr, тут еще есть олдфаги, которые помнят, как это слово нужно писать на двачах.
Ставишь Visual C++ отдельно, без студии. В папке с ним будет бинарник, которым можно компилировать из консоли, как с gcc.
Внезапно обнаружил у себя в закладках. Спасибо, пойду ставить.
QPointer, как ни странно.
Оператор new определён в libstdc++, а это не компилятор хоть и идёт, обычно, вместе с ним.
И точно так же как и маллок должен идти в ОСь, ибо откуда он память возьмёт? А зачастую он вообще маллок и пользует.
>>536856
Ну тогда откат наезда. Заработает, съест память, вскипятит океаны и заработает...
И да, кто освобождать-то память будет?
Не путай оператор new и функцию operator new. Первое - часть ядра языка, которая не имеет отношения к библиотекам, жестко зашитая в компилятор. Второе - обычная перегружаемая библиотечная функция.
Память она возьмет, но гораздо реже, чем голый маллок. Например, она может брать ее сразу по мегабайту и потом раздавать по кусочкам, или использовать хитрые платформозависимые стратегии.
https://2ch.hk/pr/res/537129.html
https://2ch.hk/pr/res/537129.html
https://2ch.hk/pr/res/537129.html
Чтобы ночью не караулить бамплимит. Добивайте этот и переходите.
Такую, какая у тебя в первой строке.
рарпр
[/code]
Это копия, сохраненная 26 сентября 2015 года.
Скачать тред: только с превью, с превью и прикрепленными файлами.
Второй вариант может долго скачиваться. Файлы будут только в живых или недавно утонувших тредах. Подробнее
Если вам полезен архив М.Двача, пожертвуйте на оплату сервера.