标签: using

例如

struct Option_1
{
    template<class T> using Vector = std::vector<T>;
};

我可以

typename Option_1::Vector<int> v;

但我更喜欢下面的

Vector<Option_1, int> v;

或不带“typename”一词的类似名称。我定义了一个别名

template<class Option, class T> using Vector= typename Option::Vector<T>;

但由于无法识别的模板声明/定义而失败。如何修复它？

我试图继承名称很长的模板基类的构造函数。对于这个基类，我引入了类型别名。（https://godbolt.org/z/aqf6czPdo）

class Object {};
class Gadget {};

class SuperBase : public Object { using base_t = Object; };
class Params : public Gadget { using base_t = Gadget; };

template<class T, class TParams>
class Base : public SuperBase, public TParams {};

template<class T>
class Derived : public Base<T, Params>
{
    using base_t = Base<T, Params>;
public:
    using base_t::base_t;
};

此代码可以使用 GCC 和 Clang 成功编译，但不能使用 MSVC/permissive-标志进行编译

error C2385: ambiguous access of 'base_t'
note: could be the 'base_t' …

在MySQL中,当您从具有相同名称的不同表中的列连接时,可以在连接中使用关键字USING.例如,这些查询产生相同的结果:

SELECT * FROM user INNER JOIN perm USING (uid)
SELECT * FROM user INNER JOIN perm ON user.uid = perm.uid

SQL Server中是否有等效的快捷方式？

我正在看一个没有正确答案解释的练习测试.我很困惑的问题基本上是为什么以下SQL语句永远不能工作:

SELECT oi.order_id, product_jd, order_date
FROM order_items oi JOIN orders o
USING(order_id);

它给出的答案是:"语句不会执行,因为USING子句的列部分在SELECT列表中不能有限定符"

有人可以详细说明吗？我很难过.

可能重复:
您是否更喜欢C++中的显式名称空间或"使用"？

嗨,大家好我是一个C#开发人员,但我的朋友是一个C++,他向我展示了充满了调用的代码,如std :: for_each和boost :: bind,我习惯在C#中使用,并认为使用指令会摇滚为了代码的可读性和通常更快的开发,例如在C#foreach语句之前键入任何命名空间将是一件痛苦的事.

我想知道使用这种流行命名空间的缺点和优点是什么？是否包含这些名称空间是最佳做法？

这看起来应该很简单,但我一直在玩,并没有找到我正在寻找的解决方案,所以这里有:

我有以下结构(当然为了说明目的而简化):

template<typename T>
struct test
    {
    using L = std::list<T>;
    L::iterator a;
    };

现在,这会引发错误:

error: need 'typename' before 'test<T>::K::iterator' because 'test<T>::K' is a dependent scope

到目前为止,我发现修复它的两种方法都不太理想:

1)在使用L之前添加typename:

template<typename T>
struct test
    {
    using L = std::list<T>;
    typename L::iterator a;
    };

如果可能的话,我宁愿避免这种额外的冗长.

2)添加另一个using语句直接定位迭代器:

template<typename T>
struct test
    {
    using L = std::list<T>;
    using iter = typename L::iterator;
    iter a;
    };

但是这需要对我想要使用的每个迭代器都做同样的事情,如果我也希望访问const_iterator等等,我宁愿不必定义一堆using语句.

那么,有没有办法编写using语句,然后允许我写:

 L::iterator a;
 L::const_iterator b;
 ...

谢谢!

所以有一段时间我一直在使用......

using namespace::std;

最近我意识到这应该是

using namespace std;

有人可以向我解释为什么我在做什么,以及它与声明使用某个命名空间的正确方法有什么不同？

关于资源密集型操作的最佳实践的共识,例如打开数据库连接,似乎是使用Using块,因为Using块"保证了资源的处理......即使在未处理的异常情况下也是如此"..

以下是我发现的大多数示例:

Sub ExecuteCommand(ByVal sql As String, ByVal connectionString As String)
    Using connection As New SqlConnection(connectionString)
        Dim command As New SqlCommand(sql, connection)
        command.Connection.Open()
        command.ExecuteNonQuery()
    End Using
End Sub

但是Using允许嵌套块,我偶尔(但很少)看到上面写的:

Sub ExecuteCommand(ByVal sql As String, ByVal connectionString As String)
    Using connection As New SqlConnection(connectionString)
        Using command As New SqlCommand(sql, connection)
            command.Connection.Open()
            command.ExecuteNonQuery()
        End Using
    End Using
End Sub

我的问题:多个嵌套Using块有什么好处吗？或者单个Using块是否已经保证它所包含的所有资源都将被处理掉？

(注意:我的代码是在VB.NET中,但同样的问题适用于C#.)

我在使用新的C++ 11 using关键字时遇到问题.据我所知,它是别名typedef.但我无法编译.我想为a的迭代器定义一个别名std::vector.如果我使用它,一切都很完美.

typedef std::vector<fix_point>::iterator inputIterator;

但如果我尝试:

using std::vector<fix_point>::iterator = inputIterator;

代码不能编译:

Error: 'std::vector<fix_point>' is not a namespace
using std::vector<fix_point>::iterator = inputIterator;
                            ^

为什么不编译？

我有一个带有一个高度模板化的免费函数的名称空间，例如：

namespace a
{
    template<typename T, typename K, typename H>
    void f(T t, K k, std::vector<H> h_vec = {})
    { /* body */ }
}

在另一个命名空间中，为了方便起见，我想为一堆特定用法使用一些别名，例如：

namespace b
{
    using my_specific_f = a::f<int,string,char>;
}

这将使我能够为函数提供更好的命名，因为f在我正在研究的代码库中这是非常通用的（请记住，我在这里仅提供简化的示例来说明这一点）。但是不幸的是，这显然是语言所禁止的。

因此，在第二次尝试中，我尝试使用函数指针：

namespace b
{
    auto my_specific_f = &a::f<int,string,char>
}

这通常可以正常工作，但是在我的情况下，由于f没有一个默认参数，因此我认为它不会导致该函数具有一个以上的函数指针（在本例中为两个），并且只能使用三个参数版本。

此时，我只是放弃了，只是简单地my_specific_f将其体内的调用重定向到f：

namespace b
{
    void my_specific_f(int i, string s, vector<char> v = {} )
    {
        a::f(i,s,v);
    }
}

但是我不太喜欢这种解决方案，因为它会导致较少的可维护性，以防万一f要更改其签名，因为所有重定向功能都需要进行协调调整，而我最初的计划是创建多个别名。

我还有什么可以尝试的吗？在将来的标准发布中甚至可能还是可能？