1. Доказательства, полученные с нарушением требований настоящего Кодекса, являются недопустимыми. Недопустимые доказательства не имеют юридической силы и не могут быть положены в основу обвинения, а также использоваться для доказывания любого из обстоятельств, предусмотренных статьей 73 настоящего Кодекса.
2. К недопустимым доказательствам относятся:
1) показания подозреваемого, обвиняемого, данные в ходе досудебного производства по уголовному делу в отсутствие защитника, включая случаи отказа от защитника, и не подтвержденные подозреваемым, обвиняемым в суде;
2) показания потерпевшего, свидетеля, основанные на догадке, предположении, слухе, а также показания свидетеля, который не может указать источник своей осведомленности;
2.1) предметы, документы или сведения, входящие в производство адвоката по делам его доверителей, полученные в ходе оперативно-розыскных мероприятий или следственных действий, за исключением предметов и документов, указанных в части первой статьи 81 настоящего Кодекса;
(п. 2.1 введен Федеральным законом от 17.04.2017 N 73-ФЗ)
2.2) полученные в ходе оперативно-розыскных мероприятий или следственных действий сведения о факте представления подозреваемым, обвиняемым специальной декларации в соответствии с Федеральным законом «О добровольном декларировании физическими лицами активов и счетов (вкладов) в банках и о внесении изменений в отдельные законодательные акты Российской Федерации» и (или) указанная декларация и сведения, содержащиеся в указанной декларации и документах и (или) сведениях, прилагаемых к указанной декларации, за исключением случаев представления декларантом копий указанных декларации и документов и (или) сведений для приобщения к уголовному делу;
(п. 2.2 введен Федеральным законом от 27.12.2019 N 498-ФЗ)
2.3) полученные в ходе оперативно-розыскных мероприятий или следственных действий сведения о факте указания подозреваемого, обвиняемого в специальной декларации, представленной иным лицом в соответствии с Федеральным законом «О добровольном декларировании физическими лицами активов и счетов (вкладов) в банках и о внесении изменений в отдельные законодательные акты Российской Федерации», и (или) сведения о подозреваемом, обвиняемом, содержащиеся в указанной декларации и документах и (или) сведениях, прилагаемых к указанной декларации, за исключением случаев представления декларантом копий указанных декларации и документов и (или) сведений для приобщения к уголовному делу;
(п. 2.3 введен Федеральным законом от 27.12.2019 N 498-ФЗ)
3) иные доказательства, полученные с нарушением требований настоящего Кодекса.
Синтаксически перегрузка операций осуществляется следующим образом:
где @ — знак перегружаемой операции (-, +, * и т.д.), тип — тип возвращаемого значения.
Например, функция перемножения матрицы и вектора может быть записана следующим образом.
Любой перегруженный оператор можно вызвать с использованием функциональной формы записи (функции-операции):
Функция-операция описывается и может вызываться так же, как любая другая функция. Использование операции – это лишь сокращенная запись явного вызова функции операции.
Имеется два способа описания функции, соответствующей переопределяемой операции:
Можно описывать функции, определяющие значения следующих операций:
Операции, не допускающие перегрузки:
Правила перегрузки операций
Перегрузка унарной операции
Если унарная операция перегружается как функция-член, то она не должна иметь аргументов, так как в этом случае ей передается неявный аргумент-указатель this на текущий объект.
Если определена и та, и другая, то и aa@ и @aa являются ошибками.
Функция- член класса
Дружественная функция
Перегрузка бинарной операции
Если бинарная операция перегружается дружественной функцией, то в списке параметров она должна иметь оба аргумента:
Результат выполнения
Для каждой комбинации типов операндов в переопределяемой операции необходимо ввести отдельную функцию, т.е. компилятор не может производить перестановку операндов местами, даже если базовая операция допускает это. Например, если необходима операция сложения комплексного и вещественного чисел:
то необходимо переопределить операцию сложения дважды:
Перегрузка операций индексирования и вызова функции
Переопределение операции () позволяет использовать синтаксис вызова функции применительно к объекту класса (имя объекта с круглыми скобками). Количество операндов в скобках может быть любым. Переопределение операции [] позволяет использовать синтаксис доступа к элементам массива (имя объекта с квадратными скобками).
Результат выполнения
Перегрузка операции присваивания
Любой конструктор вызывается явно либо неявно в том случае, если необходимо создать новый объект какого-либо класса. Рассматривая на примере создание нового объекта и его инициализацию, мы использовали конструктор копии. До проведения инициализации существовал только один объект. Второй был создан и инициализирован в результате работы конструктора копии. Однако если бы существовало несколько объектов одного типа, и была бы необходимость в присваивании значений одного объекта элементам другого, то никакой из конструкторов не вызывается, так как объект уже был создан. При выполнении операции присваивания по умолчанию копирование значений происходит «поверхностно», но такое копирование не всегда допустимо. Например, недопустимо копирование массивов или указателей. Если необходимо осуществить присваивание, но поведение операции присваивания по умолчанию не устраивает, то операция присваивания может быть перегружена. Дополним приведенный выше пример реализации класса String перегруженным оператором присваивания:
Результат выполнения:
Перегрузка операций выделения памяти
Операции создания и уничтожения объектов в динамической памяти могут быть переопределены следующим образом
Ничто не может доставить больше неприятностей, чем «дикий» указатель! Указатели похожи на обоюдоострое оружие: их возможности огромны, однако обезвредить ошибки в них особенно трудно.
Ошибочный указатель трудно найти потому, что ошибка в самом указателе никак себя не проявляет. Проблемы возникают при попытке обратиться к объекту с помощью этого указателя. Если значение указателя неправильное, то программа с его помощью обращается к произвольной ячейке памяти. При чтении в программу попадают неправильные данные, а при записи искажаются другие данные, хранящиеся в памяти, или портится участок программы, не имеющий никакого отношения к ошибочному указателю. В обоих случаях ошибка может не проявиться вовсе или проявиться позже в форме, никак не указывающей на ее причину.
Поскольку ошибки, связанные с указателями, особенно трудно обезвредить, при работе с указателями следует соблюдать особую осторожность. Рассмотрим некоторые ошибки, наиболее часто возникающие при работе с указателями. Классический пример — неинициализированный указатель :
Эта программа присваивает значение 10 некоторой неизвестной области памяти. Рассмотрим, почему это происходит. Хотя указателю р не было присвоено никакого значения, но в момент выполнения операции *р = х он имел некоторое (совершенно произвольное!) значение. Поэтому здесь имела место попытка выполнить операцию записи в область памяти, на которую указывал данный указатель. В небольших программах такая ошибка часто остается незамеченной, потому что если программа и данные занимают немного места, то «выстрел наугад» скорее всего будет «промахом». С увеличением размера программы вероятность «попасть» в нее возрастает.
В таком простом случае большинство компиляторов выводят предупреждение о том, что используется неинициализированный указатель. Однако подобная ошибка может произойти и в более завуалированном виде, тогда компилятор не сможет распознать ее.
Вторая распространенная ошибка заключается в простом недоразумении при использовании указателя:
записан неправильно. Он присваивает значение 10 указателю, однако указатель должен содержать адрес, а не значение. Правильный оператор выглядит так:
Большинство компиляторов при попытке присвоить указателю р значение х выведут предупреждающее сообщение, но, как и в предыдущем примере, компилятор не сможет распознать эту ошибку в более завуалированном виде.
Еще одна типичная ошибка происходит иногда при неправильном понимании принципов расположения переменных в памяти. Программисту ничего не известно о том, как используемые им данные располагаются в памяти, будут ли они расположены так же при следующем выполнении программы или как их расположат другие компиляторы. Поэтому сравнивать одни указатели с другими недопустимо. Например, программа
в общем случае неправильна. (В некоторых необычных ситуациях иногда определяют относительное положение переменных, но это делают очень редко.)
Похожая ошибка возникает, когда делается необоснованное предположение о расположении массивов. Иногда, предполагая, что массивы расположены рядом, пытаются обращаться к ним с помощью одного и того же указателя, например:
Так присваивать значения массивам first и second нельзя. Если компилятор разместит массивы рядом, это может и не привести к неправильному результату. Однако подобная ошибка особенно неприятна тем, что при проверке она может остаться незамеченной, а потом компилятор будет размещать массивы по-другому и программа выполнится неправильно.
В следующей программе приведен пример очень опасной ошибки. Постарайтесь сами найти ее, не подсматривая в последующее объяснение.
То, что неправильные указатели могут быть очень «коварными», не может служить причиной отказа от их использования. Следует лишь быть осторожным и внимательно проанализировать каждое применение указателя в программе.
Кратко об указателях в Си: присваивание, разыменование и перемещение по массивам
Приветствую вас, дорогие читатели. В данной статье кратко описаны основные сведения об указателях в языке Си. Кроме основных операций с указателями (объявление, взятие адреса, разыменование) рассмотрены вопросы безопасности типов при работе с ними. К сожалению, в данной статье вы не найдёте информацию по операциям сравнений указателей. Однако, статья будет полезна новичкам, а также тем, кто работает с массивами. Все примеры в данной статье компилировались компилятором gcc (восьмой версии).
Введение
Количество звёздочек лишь указывает на длину цепочек хранимых адресов. Поскольку указатель также является переменной и имеет адрес, то его адрес также можно хранить в другом указателе. В выше приведённом примере адрес переменной a сохраняется в переменной-указателе ptr. Адрес же самой переменной ptr сохраняется в другом указателе pptr. Чтобы получить адрес переменной, перед её именем надо поставить знак амперсанда (&). Наконец, чтобы выполнить обратную операцию, т.е. получить значение (содержимое) по адресу, хранимому в указателе, имя указателя предваряется звёздочкой, почти как при объявлении. Почти, потому что одной звёздочки достаточно чтобы «распаковать» указатель. Поскольку pptr указывает по адресу на значение, хранимое в ptr, то необходимо два раза применить операцию разыменования.
Указатели в предыдущем примере хранят адрес переменной определённого типа. В случае, когда применяются указатели типа void (любого типа), то прежде чем распаковать значение по адресу, необходимо выполнить приведение к типизированному указателю. Следующий пример является версией предыдущего, но с использованием указателя любого типа.
Изменения значения переменной через указатель.
Так как указатель хранит адрес переменной, мы можем через адрес не только получить значение самой переменной, но также его изменить. Например:
Как было сказано выше, указатели хранят адреса. Естественно, что адреса могут указывать не только на ячейки данных переменных в вашей программе, но и на другие вещи: адрес стека процедур, адрес начала сегмента кода, адрес какой-то процедуры ядра ОС, адрес в куче и т. д. Логично, что не все адреса можно использовать напрямую в программе, поскольку некоторые из них указывают на те участки памяти, которые нельзя изменять (доступ для чтения), или которые нельзя затирать. В случае, при обращении к участку, доступному только для чтения, при попытке изменить значение получим ошибку Segmentation Fault (SF).
Кроме того, в языке Си определён макрос с именем NULL, для обозначения указателя с нулевым адресом. Данный адрес обычно используется операционной системой для сигнала об ошибке при работе с памятью. При попытке что либо читать по этому адресу, программа может получить неопределённое поведение. Поэтому ни в коем случае не пытайтесь извлечь значение по пустому указателю.
И ещё, указатели могут указывать на один и тот же объект. Например:
Этот простой пример показывает, что через адреса можно менять содержимое простых переменных, а также остальных указателей, ссылающихся на тоже самое. Таким образом, указатель p2 как бы является псевдонимом (alias) для p1.
Передача параметров через указатели.
Параметры функций могут быть указателями. В случае вызова таких функций, они копируют значения аргументов в свои параметры как обычно. Единственное отличие здесь в том, что они копируют адреса, содержащиеся в указателях параметрах. И с помощью полученных адресов, можно изменять объекты, на которые указывают параметры. Ниже приведена стандартная процедура обмена значений между двумя целочисленными переменными.
Здесь переменные а и b меняются своими значениями друг с другом (при условии, что параметры содержат не нулевой адрес). Отметим ещё раз, что мы можем изменить содержимое, указываемое по параметру-указателю методов. И, конечно, мы можем стереть данный адрес, присвоив параметру новое значение.
Проверка типов и массивы
Постоянные (const) и указатели.
Напомним, чтобы сделать переменную с постоянным, фиксированным значением, надо добавить ключевое слово const перед её именем (до имени типа или после). Например:
Для объявления указателя на постоянное значение, ключевое слово const должно быть ПЕРЕД звёздочкой.
В примере выше была создана переменная-указатель, ссылающееся на постоянное значение. Слово const перед звёздочкой указывает, что нельзя менять содержимое напрямую (путём разыменования, обращения к ячейке). Но сама переменная указатель постоянной не является. А значит, ей можно присвоить новый адрес. Например, адрес следующей ячейки в массиве.
Тема указателей довольно сложна и мне часто присылают вопросы по ней. В этой статье мы подробно разберем тему указателей.
Рекомендуемая работа с памятью
Перед тем, как разбираться с указателями, сначала посмотрим, как лучше работать с памятью в Си.
Рекомендуемый способ — это прямо описать ту область памяти, которую вы хотите использовать.
В этом примере мы задали целое число, массив и вещественное число. То есть мы явно дали имя элементу данных.
Если мы теперь будем использовать этот элемент данных, то достаточно указать его имя.
Почему рекомендуется делать именно так? Три причины:
Причина 1. Соблюдение принципа изоляции кода
В языке Си данные в функцию передаются по значению. Эти значит, что копия входных параметров размещается на стеке. После выхода из функции эти данные уничтожаются. Поэтому программист уверен, что никакого влияния на остальную программу эти данные не окажут.
Причина 2. Простой вызов в отладчике
Просто добавьте имя элемента данных и вы можете легко наблюдать, что с ним происходит во время отладки.
Причина 3. Самодокументируемый код
Если мы дадим объектам данных осмысленные имена, то код будет хорошо читаться. Например:
Но так как язык Си универсален и есть много способов писать программы, то есть и такой способ как указатели.
Что такое указатели?
Указатель — это переменная, которая содержит адрес некоторого объекта в памяти.
Для работы с указателями используются два оператора: & — получить адрес переменной (&x — адрес переменной x)
* — получить значение переменной по адресу (*px — значение по адресу px)
Рассмотрим участок памяти. Предположим, что по адресу 54100 размещена символьная переменная char x;
При заведения указателя мы сразу говорим компилятору, что мы завели указатель на объект типа char. Чтобы не было путаницы в именах рекомендуется указатель начинать с символа «p».
Важный момент. Когда комплятор выделяет память под «char x», то выделяется один байт, потому что x — это символ, то есть это однобайтовая переменная. Но когда компилятор выделяет память под «char *px», то выделяется обычно 4 байта, так как адрес (в 32-х битовой системе) занимает 4 байта.
*px — читается как «взять значение по адресу, xранящемуся в px»
Теперь нам нужно записать:
Для этого мы пишем следующие строки:
После этого мы можем работать с этим адресом в памяти как через имя переменной, так и через указатель. Получение значение через указатель называется разыменование указателя.
Но тут нужно быть осторожным. Если в указателе лежит адрес, который не выделен программе, то эта ситуация называется висячий указатель.
Предположим, что px — это висячий указатель. Действия с самим указателем px могут быть любыми, программа не пострадает. Но если мы выполним действие *px над памятью, которая не была выделена программе, то операционная система прекратит действие программы и напишет что-то вроде: «Программа выполнила недопустимую операцию и будет закрыта».
Преимущество указателей
Преимущество указателей в том, что они позволяют передать в функцию значение по ссылке. Слово «ссылка» означает, что мы не передаем значение, а ссылаемся на адрес этого значения. В этом случае можно внутри функции изменять значение элемента данных. Хотя указатель и будет уничтожен после выхода из функции, но мы изменили значение памяти по указателю и это изменение значения сохранится после выход из функции.
Именно поэтому их часто используют.
Недостатки указателей
Главные недостатки указателей:
1. Нарушение принципов изоляции кода
Ошибка в указателе может привести к тому, чтобы будет испорчена память в случайном месте. Хорошо еще, если повезет и программа рухнет, тогда программист сразу заметит ошибку. Но если программа продолжит работу, то найти ошибку будет очень сложно, ведь она не сразу проявляется.
2. Отвлечение внимание на детали реализации
При использовании указателей программисту нужно держать в уме принципы работы с памятью, а это отвлекает от сути задачи, которая решает программист. При правильном подходе к программированию программист должен думать только решаемой задаче, и не отвлекаться на посторонние детали.
3. Плохая читаемость кода
Прямое использование переменной является самоочевидной вещью. Если мы видим x++, то сразу понимаем, что происходит, а вот если мы видим (*px)++ или *px++, то чтобы понять процесс, нужно вдумываться.
Сравним два варианта кода. Код с переменными:
и код с указателями
Мы видим, что с указателями читаемость кода хуже, а преимуществ никаких мы не получили.
Указатели лучше вообще не использовать.
Конечно же, на это последует вопрос: «А как тогда изменять значения внутри функции?»
Этот код поменяет значения любых элементов массива.
Если же речь идет именно о переменных, то правильный ответ такой: если вам нужно изменять внешние значения переменных внутри функции — у вас неверно спроектирована программа.
В правильно спроектированной программе есть три вида элемента данных:
Для указателей при таком подходе места нет. Но так как указатели широко используются в различных библиотеках, то работать с ними надо уметь.
Ответы на вопросы
Вопрос
Мы сначала передали адрес a в функцию AddFive, затем создали указатель int px(но почему именно в аргументе функции?), далее значение по адресу указателя увеличили на 5. Но тут непонятно, разве так будет работать? То есть, нужно сначала адрес присвоить указателю, как Вы показывали ранее в статье. Получится вот так:
Ответ
В аргументах функции ничего не создается. В аргументах указываются типы, чтобы компилятор мог проверить их при вызове функции. Адрес указателю px не надо присваивать внутри функции, так как этот адрес уже передан в качестве аргумента при вызове функции. То есть во время работы функции указатель px уже указывает на нужный адрес.
Вопрос
Я проверил код в CodeBlocks. Если мы укажем, например, вот так:
то возникнет ошибка: «px undeclared». Т.е. как видите указатель px не объявлен. А чтобы всё работало мы одновременно, c одной стороны, объявляем указатель в аргументе функции AddFive, а с другой стороны, записываем в указатель адрес a. Поэтому, непонятно почему Вы считаете, что ничего там не создаётся. Ведь память под указатель выделилась, так? И как раз, так как мы создали указатель, пусть и в аргументе функции, программа и работает.
Ответ
На этапе компиляции программы при проверке аргументов функции компилятор ничего не создает, а только проверяет соответствие типов аргументов в описании функции и при ее вызове. В данном примере в описании функции нет аргументов, а при вызове передается адрес — это первая ошибка в данном фрагменте. Вторая ошибка заключается в том, что идет обращение к переменной px, но она не объявлена, поэтому компилятор пишет, что «px undeclared», то есть «переменная px не объявлена».
Когда ошибки будут устранены и программа будет запущена, то в момент вызова AddFive(&a) произойдет следующее:
То есть в данном примере память для указателя специально не создается, а используется обычный стек для аргументов функции.
