问题是关于结构.当我声明一个struct类型的变量/对象(不知道哪个更适合)或者一个数组或结构列表时,我是否必须像对象一样明确地调用构造函数,或者只是声明就像变量一样？
我通过派生类体验过这一点,但它与QDialog基类相同:
当我做
QDialog dialog();
dialog.exec();
编译器抱怨
J:\...\mainwindow.cpp:-1: In member function 'void MainWindow::on_viewButton_pressed()':
J:\...\mainwindow.cpp:72: Fehler:request for member 'exec' in 'dialog', which is of non-class type 'QDialog()'
这与使用的构造函数有关,因为当我这样做时
QDialog dialog(0);
dialog.exec();
代码编译没有错误.这也有效:
QDialog *dial = new QDialog();
dial->exec();
所以.是因为一个显式的构造函数？
文档称其定义为
QDialog::QDialog ( QWidget * parent = 0, Qt::WindowFlags f = 0 )
那么前两个例子不应该完全一样吗？为什么编译器会抱怨第二行,而不是构造函数.
感谢您的启发,非常欢迎进一步阅读该主题的提示
隐式转换似乎是Scala的一个主要且有争议的特性,而它们似乎在C#中的突出程度要小得多.它们在两种语言中有什么区别？有没有我在Scala中被迫使用implicits的地方,或者我总是可以选择是否希望转换是隐式的还是显式的,就像在C#中一样？通常在C#中,我喜欢明确地进行转换,以便维护程序员意图的类型检查,即使消费者是我自己.
我是否正确地说C#或Scala都不能隐式拆分或组合方法/函数参数？在def myMethod(v1:Int,v2:Int)中不接受Tuple2 [Int,Int]作为其参数列表,def yourMethod(v1:Tuple2 [Int,Int])将不接受两个整数作为其参数列表.据推测,语言设计者必须考虑隐式/显式参数分割/组合.当使用多个但相似的图形库的点结构时,我确实发现这个特性是可取的.
我的代码按预期工作:
EscapedString es("Abc&def");
EscapedString es2("");
es2 = es; // es2 == Abc%26def
并且代码不能按预期工作:
EscapedString es("Abc&def");
EscapedString es2 = es; // es == Abc%2526def
在第二种情况下,即使es是EscapedString,也会调用CTOR2而不是CTOR3.
EscapedString es(EscapedString("Abc?def"));
是对的,但我似乎无法在CTOR3上设置断点,所以我不确定它是否正常工作,或者代码已被优化掉或者它是意外工作的.
课程如下:
class EscapedString : public std::string {
public:
EscapedString(const char *szUnEscaped) { // CTOR1
*this = szUnEscaped;
}
EscapedString(const std::string &strUnEscaped) { // CTOR2
*this = strUnEscaped;
}
explicit EscapedString(const EscapedString &strEscaped) { // CTOR3
*this = strEscaped; // Can't set breakpoint here
}
EscapedString &operator=(const std::string &strUnEscaped) {
char *szEscaped …这是交易：
当我有一个带有像这样的默认参数的函数时
int foo (int a, int*b, bool c = true);
如果我错误地这样称呼它：
foo (1, false);
编译器会将 false 转换为 int 指针并调用 b 指向 0 的函数。
我见过人们建议使用模板方法来防止隐式类型转换：
template <class T>
int foo<int> (int a, T* b, bool c = true);
但这种方法太混乱并且使代码变得混乱。
有显式关键字，但它仅适用于构造函数。
我想要的是一种与显式方法类似的干净方法，这样当我声明该方法时，如下所示：
(keyword that locks in the types of parameters) int foo (int a, int*b, bool c = true);
并这样称呼它：
foo (1, false);
编译器会给我这个：
foo (1, false);
^
ERROR: Wrong type in function call (expected int* but got bool)
有这样的方法吗？
struct Foo
{
explicit Foo(int a):m(a){}
int padd1, m, padd2;
};
void Bar(Foo){}
int main()
{
Bar(11); // OK, gives error
auto x = static_cast<Foo>(37);
x.m;
}
即使构造函数被标记,static_cast构造Foo对象也没关系explicit吗？
它适用于MSVC2013和GCC http://ideone.com/dMS5kB
我希望能够清楚准确地理解两者之间的区别.
this用于隐式引用还是显式的关键字也是？这也是我想要在两者之间澄清的原因？
我假设使用this关键字is隐式引用(是类的东西)而显式(不属于类本身)就像传递给方法的参数变量一样.
当然,我的假设显然是错误的,这就是我在这里要求澄清的原因.
我正在将旧版 Android 应用程序从 Eclipse 迁移到 Android Studio。
大约 3-4 年前，旧版本的 Android 一切都运行良好。
现在，当我在 Android 7.0 上运行该应用程序时，android.vending.licensing会产生以下（服务意图必须明确）致命异常：
java.lang.RuntimeException: Failure delivering result ResultInfo{who=@android:requestPermissions:, request=110, result=-1, data=Intent { act=android.content.pm.action.REQUEST_PERMISSIONS launchParam=MultiScreenLaunchParams { mDisplayId=0 mFlags=0 } (has extras) }} to activity {HexagoniaGalaxyS7.hexagoniagalaxys7.apk/hexagoniagalaxys7.apk.HexagoniaActivity}: java.lang.IllegalArgumentException: Service Intent must be explicit: Intent { act=com.android.vending.licensing.ILicensingService launchParam=MultiScreenLaunchParams { mDisplayId=0 mFlags=0 } }
Caused by: java.lang.IllegalArgumentException: Service Intent must be explicit: Intent { act=com.android.vending.licensing.ILicensingService launchParam=MultiScreenLaunchParams { mDisplayId=0 mFlags=0 } }
这是我的代码：
String deviceId = tManager.getDeviceId();
licenseCheckerCallback = new HexagoniaLicenseCheckerCallback(); …我正在尝试创建一个专门用于某些给定类型的全局函数模板。它看起来像这样：
啊（主模板，模板特化，extern）
template <typename T> void foo() { std::cout << "default stuff" << std::endl; }
template<> void foo<int>() { std::cout << "int stuff" << std::endl; }
extern template void foo<int>();
A.cpp（显式实例化）
template void foo<int>();
乙
void bar();
B.cpp（包括啊）
void bar() { foo<int>(); }
主程序
foo<int>();
bar();
编译器让我崩溃：“'void foo()' 的多个定义。我认为 extern 应该处理这个问题。B 编译单元不应该实例化 foo，而是在链接时使用 A 实例化，没有? 我哪里错了？
请注意，如果我不专门化 foo，则代码编译得很好。函数特化和实例化之间是否存在某种冲突？
explicit可以用于例如。一个构造函数或转换函数，以避免隐式调用该构造函数/转换 - 简而言之。
我想知道是否有可能以某种方式显式地明确单个参数（缺少滚动新类型）？也许使用编译器扩展？
使用引用使复制构造变得不可能，因此这是一种解决方案，尽管不是我正在寻找的解决方案。有时能够explicit在功能级别强制执行将是简洁的工具/界面说明符。
void f(std::string& s); //cannot copy convert into s
void f(const std::string& t);//calling with char* allowed
特别是对于字符串，应该使用什么类型来避免从char*?