以下两段代码之间有什么区别:
using (Object o = new Object())
{
// Do something
}
和
{
Object o = new Object();
// Do something
}
我已经开始使用using更多但是我很好奇与范围对象相比实际上有什么好处.
编辑:我从中获取的有用花絮:
Jon Skeet:
请注意,这不会以任何方式,形状或形式强制进行垃圾收集.垃圾收集和快速资源清理有些正交.
埃德斯会评论:
除非您的类实现了IDisposable接口,并且具有Dispose()函数,否则不要使用.
以下是纯粹学术上发明的类层次结构.
struct X{
void f1();
void f2();
void f3();
};
struct Y : private X{
void f4();
};
struct Z : X{
};
struct D : Y, Z{
using X::f2;
using Z::X::f3;
};
int main(){}
我期望使用X :: f2的声明是模糊的,因为'X'是'D'的可模糊基础(可见性与X的可访问性).但是g ++(ideone.com)编译得很好.
我使用Online Comeau进行了检查,并且在预期使用X :: f2的声明时出错.但是,它也为使用Z :: X :: f3的声明提供了歧义.
那么预期的行为是什么？
编辑1:
请参考标准的相应部分.
编辑2:
我查看了VS 2010,它只对使用声明X :: f2提出异议.然而,它不是关于'X'的歧义(如gcc和Comeau的情况).这是关于"错误C2876:'X':并非所有重载都可以访问".
编辑3:
struct X{
void f(){}
};
struct Y : X{
struct trouble{
void f(){}
};
};
struct trouble : X{
};
struct letscheck : Y, …任何人都可以告诉我如何使用模拟对象使用Moq框架返回数据列表,并将返回的数据列表分配给另一个List <>变量.
我有这个小班widget使用了std::string.它在许多地方使用它,通常与a结合使用std::vector.所以你可以看到,类型名称变得非常冗长和烦人.
我想利用using关键字,即using std::string;
问题是,放置它的最佳位置在哪里？
// widget.h file
#ifndef WIDGET
#define WIDGET
// (1)
namespace example {
// (2)
namespace nested {
// (3)
class widget {
public:
// (4)
...
private:
// (5)
std::string name_;
...
};
}
}
#endif
我的问题是:
(1)那么所有包含的人widget.h都会被污染的范围string？(2)和(3),这是同样的故事在1只,该命名空间example,并example::nested会在包括第二个文件被污染widget.h？(4)和(5),声明是相当孤立的,但它会在实现(Cpp)文件和继承类中可见吗？提前致谢!
C++ 11添加了别名模板,例如:
template<typename T> using identity = T;
template<bool b, typename T = void> using EnableIf = typename std::enable_if<b, T>::type;
这些比template在::type字段中提供返回值的旧类型映射更容易使用,因为即使您的类型参数依赖于本地上下文,您也不需要通知编译器结果是类型.
实际上,您将typename使用位置提升到using别名.
有没有什么可以用来摆脱生产无关的templates？
假设您有一个元函数,其输出是类或别名模板而不是类型.目前的方法是这样的:
template<typename T>
struct my_meta {
template<typename U>
using Template = identity<U>;
};
template<typename T>
struct my_meta {
template<typename U>
using Template = int;
};
我们可以这样使用:
template<typename T, typename U>
typename my_meta<T>::template Template<U>
do_stuff( U&& ) { return {}; }
template返回类型中的额外关键字存在以消除我的元函数的返回值的歧义是我想要消除的.
有没有办法向编译器指示metacomputation的结果是C++ 11或C++ 1y中的另一个别名或类模板,而不template在调用位置使用关键字？ …
我有一个问题,它会侵入嵌套的命名空间和模板化的类.我还能够创建测试用例,它产生与实际代码相同的错误,但更具可读性.
使用VS2012和2010平台工具集编译以下代码会导致错误:
namespace A
{
namespace B
{
namespace C1
{
struct SMeasResult{};
}
namespace C2
{
struct SMeasResult{};
}
}
}
namespace C1Test
{
using namespace A::B::C1;
template<typename T>
class Fook
{
public:
void Yu()
{
SMeasResult Field;
}
};
}
namespace C2Test
{
using namespace A::B::C2;
template<typename T>
class Fook
{
public:
void Yu()
{
SMeasResult Field;
}
};
}
void m(){
C1Test::Fook<int> yu;
C2Test::Fook<int> me;
yu.Yu();
me.Yu();
}
具体错误如下:
1>------ Build started: Project: MultiVicomTest (Visual Studio 2010), …我遇到了以下代码（用基本类型简化）：
template <typename T>
class Base {
T t;
};
class Derived : public Base<short> {
public:
using Base<short>::Base;
};
int main() {
Derived::Base<long long> x;
printf("%lu\n", sizeof(x));
return 0;
}
它可以编译工作（输出为8，这是long long的大小）。看起来我可以使用Base<T>任何类型的T数据Derived::Base，即使Derived只是Base<short>。（在我遇到的代码中，Base它本身不可见main。）
但是，我不太了解这种语法及其工作原理。
是Derived::Base模板名称，类还是函数（ctor）？似乎是模板名称。模板名称在实例化此模板的所有类中都可用（例如，所有类型的模板名称Base都在其中）？我很混乱。任何对cppreference或C ++标准的解释或指针均应赞赏。Base<T>T
我可以using在使用括号中直接找到C#实例化的所有在线示例:
using (var cnx = new SqlConnection()) { }
我认为以下应该采取相同的行动,但我似乎仍然锁定了资源:
SqlConnection GetConnection() { return new SqlConnection(); }
void foo()
{
using (var cnx = GetConnection()) { }
}
当我单步执行我的程序并进入使用的右大括号后面的行时,我希望能够以任何方式使用SQL Server Management Studio更改数据库,但我不能.当我关闭我的应用程序时,错误消失了.
这不是隔离到SQL; 我也通过这种方式打开文件流来体验这一点.那就是:超越using块,但操作系统不允许外部应用程序更改文件.
我违反了using合同的某些部分吗？
是否可以using为文字运算符声明operator ""？
例如,
#include <chrono>
namespace MyNamespace
{
constexpr std::chrono::hours operator "" _hr(unsigned long long n){
return std::chrono::hours{n};
}
// ... other stuff in the namespace ...
}
using MyNamespace::operator""; // DOES NOT COMPILE!
int main()
{
auto foo = 37_hr;
}
我的解决方法是将这些运算符放在它们自己的嵌套命名空间中literals,这允许using namespace MyNamespace::literals;,但这似乎有点不优雅,我不明白为什么using指令不能以operator相同的方式用于函数命名空间中的任何其他函数或类型.
我以为我已经了解 C# 中的异常处理是如何工作的。重新阅读文档以获得乐趣和自信，我遇到了问题：
该文档声称以下两个代码片段是等效的，甚至在编译时将第一个代码片段转换为后一个代码片段。
using (Font font1 = new Font("Arial", 10.0f)) {
byte charset = font1.GdiCharSet;
}
和
{
Font font1 = new Font("Arial", 10.0f);
try {
byte charset = font1.GdiCharSet;
}
finally {
if (font1 != null)
((IDisposable)font1).Dispose();
}
}
此外，它还声称：
using 语句确保 Dispose 被调用，即使在您调用对象的方法时发生异常。
相比之下，该文件指出：
在处理的异常中，
finally保证运行关联的块。但是，如果未处理异常，则finally块的执行 取决于触发异常展开操作的方式。
我不明白这一点。在第一个文档的代码示例中，异常显然是未处理的（因为没有 catch 块）。现在，如果第二个文档中的语句为真，finally则不能保证执行该块。这最终与第一个文件所说的（“using声明确保......”）（强调我的）相矛盾。
那么真相是什么呢？
编辑 1
我还是不明白。StevieB 的回答让我从 C# 语言规范中阅读了更多部分。在 16.3 节中，我们有：
[...] 这种搜索一直持续到找到可以处理当前异常的 catch 子句为止。 …