"Bar"以下代码不是输出预期的字符串,而是输出看起来像指针的内容.
#include <sstream>
#include <iostream>
int main()
{
std::stringstream Foo("Bar");
std::cout << Foo << std::endl; // Outputs "0x22fe80."
return 0;
}
这可以通过使用来解决Foo.str(),但它在过去给我带来了一些问题.是什么导致这种奇怪的行为 它在哪里记录？
我最近开始使用这std::reference_wrapper门课.当替换原始引用的某些用法时,我注意到我没有必要使用该get()函数将reference_wrappers作为参数传递给采用普通引用的函数.
void foo(const T& a);
//...
T obj;
std::reference_wrapper<const T> ref(obj);
foo(ref); //works!
//foo(ref.get()); also works, but I expected that it would be required
std::reference_wrapper当它传递给函数时,如何隐式转换为原始引用？
我是斯卡拉新手,我注意到了一个我不明白的行为.当我执行此代码时,一切都很顺利:
val lD: List[Double] = List(1, 2, 3)
但是当我执行这个时:
val lI = List(1, 2, 3)
val lD: List[Double] = lI
我收到一个错误
<console>:11: error: type mismatch;
found : List[Int]
required: List[Double]
请您告诉我为什么在第二个列表中没有进行隐式转换？
我有一个功能模板(c ++)
template<typename T>
void print_to_default_file(T &obj, ADDON addon = "")
和一个重载的功能
template<typename T>
void print_to_default_file(T &obj, std::string objS) // or char* objS
该类ADDON具有以下签名的运算符重载
void operator=(const std::string)
问题是,当我执行print_to_default_file("测试","我将去哪里")
它正在呼叫第一个,但我想打电话给第二个.我也厌倦了char*而不是std :: string但结果是一样的.
有人可以指出出了什么问题
ADDON简化版
class ADDON {
std::string s;
public:
ADDON() {
s = "";
}
ADDON(std::string in) {
s = in;
}
ADDON(const char in[]) {
s = in;
}
void operator=(const std::string in) {
s = in;
}
std::string getString() {
return s; …c++ templates overloading overload-resolution implicit-conversion
有没有人有一个雄辩的解决方案,因为缺乏对C#中非静态隐式运算符的支持？以下代码显示了我当前的问题:
class Foo
{
public int x { get; set; }
public int y { get; set; }
public Foo()
{
}
public static implicit operator Foo(Bar b)
{
Foo newFoo = new Foo();
newFoo.y = b.y;
return newFoo;
}
}
class Bar
{
public int y { get; set; }
public Bar()
{
}
}
Foo foo = new Foo();
foo.x = 42;
Bar bar = new Bar();
bar.y = 52;
foo = bar;
Console.WriteLine(foo.x); // THIS PRINTS 0 …我设法在scala中为Integer定义一个新的运算符:"!" 阶乘算子.同时,我想在没有点运算符的情况下调用它,这样就不会抛出任何警告(我不想禁用警告功能).可能吗 ？
这是我的测试代码:
implicit.scala
implicit class IntegerUtils(wrapped:Int) {
def !() = (2 to wrapped).product
}
(1 to 5).foreach { v => println (v.!) }
gcc 4.8.4警告1u << 63ul?(假设64位long和32位int)并计算0.这是正确的(没有晋升1u到1ul转移之前)？
ISO/IEC 9899:201x,6.3.1.8(通常的算术转换):"许多期望算术类型的操作数引起转换的运算符"; 6.5.7(按位移位运算符):"对每个操作数执行整数提升......".
但我无法得出结论.哪些是"很多运营商"？据我所知,"整数提升"不属于宽泛的类型int(我是否正确？),但标准没有明确声明对于隐式类型转换不考虑按位移位的右操作数.
我对涉及引用和std :: reference_wrapper的一些代码感到困惑,我不清楚这是否是我的错,因为我误解了引用包装器的工作原理或者我遇到编译器错误.
我有一个简单的映射,将对象的引用与复杂类配对:
std::unordered_map<Object const &obj, int32_t value> myMap;
(为简单起见,我明确地省略了地图编译所需的哈希和相等的仿函数)
由于我不能直接在地图中使用引用,我使用它的引用包装:
std::unordered_map<std::reference_wrapper<const Object> obj, int32_t value> myMap;
现在,我的地图填充在以下功能中:
void myFunction(Object const &obj, int32_t value)
{
...
myMap.emplace(std::make_pair(obj, value));
}
但该代码虽然编译,但不起作用.但是,这个按预期工作:
void myFunction(Object const &obj, int32_t value)
{
...
myMap.emplace(std::pair<std::reference_wrapper<const Object>, int32_t>(obj, value));
}
(在第二个版本中注意我还没有明确地为obj构建一个引用包装器)
所以,我的怀疑是:
我是否误解了参考包装器的用法？从引用到reference_wrapper没有隐式转换？如果没有,为什么代码首先编译？
或者这是std :: make_pair中的已知问题/缺陷无法正确扣除传递给它的类型？
这听起来像是一个愚蠢的问题，但是我对以下行为感到困惑：
void funcTakingRef(unsigned int& arg) { std::cout << arg; }
void funcTakingByValue(unsigned int arg) { std::cout << arg; }
int main()
{
int a = 7;
funcTakingByValue(a); // Works
funcTakingRef(a); // A reference of type "unsigned int &" (not const-qualified)
// cannot be initialized with a value of type "int"
}
经过仔细考虑，这是有道理的，因为在传递值时会创建一个新变量并可以进行转换，但是在传递变量的实际地址时并不需要那么多，就像在C ++中，一旦使变量的类型不能真的改变了。我认为这类似于这种情况：
int a;
unsigned int* ptr = &a; // A value of type int* cannot be used to
// initialise an entity of type "unsigned int*"
但是，如果我使ref函数采用const，则转换有效：
void …使用比较运算符比较具有相同值的int和float变量时会发生什么？
main( )
{
int x = 3 ;
float y = 3.0 ;
if ( x == y )
printf ( "\nx and y are equal" ) ;
else
printf ( "\nx and y are not equal" ) ;
}
output : x and y are equal
What happens when x is compared with y variable?