在Java类中,可以定义一个方法final,以标记此方法可能不会被覆盖:
public class Thingy {
public Thingy() { ... }
public int operationA() {...}
/** this method does @return That and is final. */
public final int getThat() { ...}
}
这很清楚,它可能有助于防止意外覆盖,或者表现 - 但这不是我的问题.
我的问题是:从OOP的角度来看,我理解通过定义一个方法final,类设计者承诺这个方法将始终如所描述或隐含的那样工作.但是,这通常可能超出了班级作者的影响,如果该方法所做的事情比传递财产更复杂.
句法约束对我来说很清楚,但OOP意义上的含义是什么？final大多数班级作者在这个意义上是否正确使用？
final方法承诺什么样的"合同" ？
如何在android中发送大短信.我用了 :
SmsManager sms = SmsManager.getDefault();
sms.sendTextMessage(contactNos[j], null,msgs[i], sentPI, deliveredPI);
此代码仅适用于160个字符的消息.我也用
ArrayList<String> msgsplit=sms.divideMessage(msgs[i]);
ArrayList<PendingIntent> listOfIntents = new ArrayList<PendingIntent>();
for (int k=0; k < msgsplit.size(); k++){
Intent sentIntent = new Intent();
PendingIntent pi = PendingIntent.getBroadcast(MultipleMsg.this, 0, sentIntent, PendingIntent.FLAG_CANCEL_CURRENT);
listOfIntents.add(pi);
}
// sendMessage(contactNos[j],msgs[i]);
sms.sendMultipartTextMessage(contactNos[j],null,msgsplit, listOfIntents, null);
但它会在邮件中发送垃圾字符.谁能帮我？
下面的代码在Visual Studio 2013,gcc 4.8,clang 3.4和clang 3.5(Apple LLVM 6.0)中编译,但不在clang 3.6中编译(通过Apple LLVM 6.1)
代码是我们代码库中复杂类的简化版本,这是展示问题所需的最低要求.
问题的关键在于,复制结构TYPED_VALUE是在3.6中,STRING因为存在接受a的构造函数而对类型的模板化转换运算符进行求值STRING; 这导致std::is_constructible被评估导致它需要定义STRING(我们在这里不能提供 - 将导致完整代码中的循环依赖).
class STRING;
class TYPED_VALUE
{
public:
TYPED_VALUE( const TYPED_VALUE& ) = default; // explicit or implicit doesn't make a difference
TYPED_VALUE( const STRING & ) {}
template< typename TYPE, typename std::enable_if<!std::is_pointer< TYPE >::value && !std::is_constructible< TYPE, const STRING& >::value && !std::is_constructible< TYPE, bool >::value, int >::type = 0 >
operator TYPE( void ) const …clang conversion-operator language-lawyer overload-resolution c++11
我碰到一个C++之间不一致gcc(版本4.8.1,4.8.2)和clang(版本3.3,3.4).我想知道哪一个是正确的.这是程序:
template < typename T > struct Result {};
template < typename T > struct Empty {};
template < typename T >
struct Bad_Type_Fcn {
typedef typename Empty< T >::type type;
};
template < typename T >
Result< T >
f( const T& ) {
return Result< T >();
}
template< class U >
Result< typename Bad_Type_Fcn< U >::type >
f( const U&, int ) {
return Result< …做一些事情是否有意义,例如放入一个std::lock_guard额外的范围,以便锁定时间尽可能短？
伪代码:
// all used variables beside the lock_guard are created and initialized somewhere else
...// do something
{ // open new scope
std::lock_guard<std::mutex> lock(mut);
shared_var = newValue;
} // close the scope
... // do some other stuff (that might take longer)
除了锁定持续时间短之外还有其他优点吗？
什么可能是负面影响？
某些类型转换<type_traits>也可以使用核心语言语法表达(例如std::add_const<T>::type,/似乎等同于const T).Dtto for std::add_lvalue_reference,也许是其他人.这些类型特征有什么用？
我完全理解标准会提供一个没有它们的"不完整的工具箱",我可以想象以元方式使用,如下所示:
template<typename In, template <typename> class Modifier>
struct Apply {
typedef typename Modifier<T>::type Out;
};
Apply<int, std::add_const>
是否存在可以在语法上表达的这些特征的任何其他用例,或者它们是否仅仅是"出于完整感"和偶尔的元使用？
看看下面的代码:
struct A {
public:
virtual void f(){std::cout << "in A";};
};
struct B : A{
public:
virtual void f(){std::cout << "in B";};
int a;
};
struct C : B{
using A::f;
void test(){f();}
};
int main()
{
C c;
c.f(); // calls B::f, the final overrider
c.C::f(); // calls A::f because of the using-declaration
c.test(); //calls B::f
return 0;
}
根据我的理解,B::f()in C应该隐藏使用声明A::f()带来的内容C; 如果是的话,为什么c.C::f()还要打电话A::f()？
如果c.C::f()调用A::f(),这应该意味着,在范围 …
我最近在回答一个关于p < q当p和q是指向不同对象/数组的指针时在C 中执行的未定义行为的问题。这让我想到：C ++ <在这种情况下具有相同（未定义）的行为，但是还提供了标准库模板std::less，该模板保证可以返回与<可以比较指针时相同的东西，并在不能比较时返回一些一致的顺序。
C是否提供具有类似功能的东西，从而可以安全地比较任意指针（相同类型）？我尝试浏览C11标准并没有发现任何东西，但是我在C中的经验比在C ++中小得多，因此我很容易错过一些东西。
c pointers memory-model undefined-behavior memory-segmentation
我是使用说明noexcept符的新手,我不明白为什么std::array::front和std::array::back没有声明noexcept(而是std::array::begin和std::array::end).
这是什么原因？