Вопрос о константе C++
Ну ... из того, что я видел, абсолютно нормально работает следующее, не забывайте просто немного помочь при выводе некоторых типов
import java.util.{stream => jStream}
import java.util.{function => jFunction}
def funToFunction[InT, OutT](fun: InT => OutT): jFunction.Function[InT, OutT] =
new jFunction.Function[InT, OutT] {
override def apply(t: InT): OutT = fun(t)
}
final case class AbcTest(value: String)
val javaList =
jStream.Stream.of("a", "b")
.map[AbcTest](funToFunction((s: String) => AbcTest(s)))
.collect(jStream.Collectors.toList[AbcTest])
7 ответов
Ключевое слово константы в первом примере бессмысленно. Вы говорите, что не планируете изменение указателя. Однако указатель был передан значением и так это, DOS не имеет значение, изменяете ли Вы его или нет; это не произведет вызывающую сторону. Точно так же Вы могли также сделать это:
// In header
class Foo {
void foo( int b );
};
// In cpp
void Foo::foo( const int b ) {
//Stuff
}
Можно даже сделать это:
// In header
class Foo {
void foo( const int b );
};
// In cpp
void Foo::foo( int b ) {
//Stuff
}
Так как интервал передается значением, constness не имеет значения.
Во втором примере Вы говорите, что Ваша функция берет указатель на один тип, но затем реализуйте его как взятие указателя на другой тип, поэтому это перестало работать.
Посмотрите этот вопрос, этот вопрос и этот вопрос.
В основном константа только означает, что функция не изменит значение указателя. Содержание указателей не является константой, то же как подпись заголовка.
В первом Вы обещали компилятору, но не другим пользователям класса, что не отредактируете переменную.
В Вашем втором примере Вы обещали другим пользователям класса, что не отредактируете их переменную, но отказавший для поддержки того обещания.
Я должен также отметить, что существуют явные различия между
bar* const variable
и
const bar* variable
и
const bar* const variable
В первой форме никогда не будет изменяться указатель, но можно отредактировать объект, на который указывают. Во второй форме можно отредактировать указатель (укажите на него на другой объект), но никогда переменная, на которую это указывает. В конечной форме Вы ни не отредактируете указатель, ни объект, на который это указывает. Ссылка
Для добавления немного большего количества разъяснения к указанному вопросу можно всегда обещать БОЛЬШЕ константы, чем меньше. Учитывая класс:
class Foo {
void func1 (int x);
void func2 (int *x);
}
Можно скомпилировать следующую реализацию:
Foo::func1(const int x) {}
Foo::func2(const int *x) {}
или:
Foo::func1(const int x) {}
Foo::func2(const int* const x) {}
без любых проблем. Вы сказали Вашим пользователям, что можно возможно отредактировать их переменные. В Вашей реализации Вы сказали компилятору, что эта конкретная реализация не отредактирует те переменные, даже при том, что сказанный пользователи Вы могли бы. Вы не нарушили обещание пользователю, и таким образом, код компилирует.
Так вторая константа в:
void Foo::foo(const bar* const);
Разве часть сигнатуры метода не?
Это более просто понять с типом переменной кроме указателя. Например, у Вас может быть следующее объявление функции:
void foo( int i );
Определение может быть похожим на это:
void foo( const int i ) { ... }
Является ли переменная, 'я' - константа или не на стороне определения, деталью реализации. Это не оказывает влияния для клиентов той функции.
В первом, const не влияет на интерфейс, только реализация. Вы говорите компилятору, "Я не собираюсь изменять значение bar* в этой функции". Можно все еще изменить то, на что указывает указатель. В последнем Вы говорите компилятор (и все вызывающие стороны), что не изменитесь bar структура, что bar* точки к.
Это, вероятно, не заботится очень о void Foo::foo(bar* const pBar) потому что то, как Вы рассматриваете сам указатель (константа или не) не имеет значения один бит за пределами стандартной программы. В правилах C говорится, что никакое изменение в pBar не переместится за пределами нечто так или иначе.
Однако, если это (const bar* pBar), это имеет значение, потому что это означает, что компилятор не должен позволять вызывающим сторонам передавать в указателях на объекты неконстанты.