标签: implicit-conversion

在Scala v2.9.2(和2.8.0)中,此脚本:

case class MyString(s: String)
implicit def stringToMyString(s: String) = MyString(s)
implicit val defaults: Map[String, MyString] = Map("abc" -> MyString("123"))

case class HasDefaults(name: String = "none", 
    baseMap: Map[String, MyString] = Map.empty) {
  def add(kvp: (String, MyString)*)(implicit defaults: Map[String, MyString]) =
    this.copy(baseMap = this.baseMap ++ defaults ++ kvp)
}

val hasDefaults = HasDefaults() add (
  "def" -> "124",
  "xyz" -> MyString("999")
)

println(hasDefaults)

失败:

java.util.NoSuchElementException: key not found: 124
    at scala.collection.MapLike$class.default(MapLike.scala:224)
    at scala.collection.immutable.Map$Map1.default(Map.scala:106)
    at scala.collection.MapLike$class.apply(MapLike.scala:135)
    at scala.collection.immutable.Map$Map1.apply(Map.scala:106)
    at Main$$anon$1.<init>(HasDefaults.scala:12)

它试图将String值 …

我试图消除数据库中的隐式转换.

我在UpdatedByID字段上添加了下面的CAST语句,因为这是一个Char(10),它在FROM语句中加入了一个INT.但我仍然得到隐含的转换.我一定错过了一些明显的东西？

        SELECT DISTINCT ba.BookingID INTO #temp1
        FROM BookedItemsAudit_tbl bia  
        INNER JOIN BookingAudit_tbl ba ON bia.BookingAuditID = ba.BookingAuditID    
        INNER JOIN User_tbl u ON  u.UserId  = CAST(ba.UpdatedById AS INT)
        WHERE bia.BookedItemTypeId IN (1, 58, 60)   
        AND u.UserId = 5

这是减少的架构

BOOKINGAUDIT_TBL
Column_name     Type        Length
BookingAuditID  int         4
BookingID       int         4
UpdatedByID     CHAR        10
UpdatedBy       varchar     50
UpdatedDate     datetime    8
TotalMargin     money       8
BookingStatusId int         4

 USER_TBL
 Column_name    Type        Length
 UserId         int         4
 FullName       varchar     100
 UserName       varchar     20

此链接中的完整查询和架构

SQL小提琴

附加是提示出现在执行计划中时的错误消息

我已经学会了为我的类使用隐式运算符.

现在我想做这样的事情:

public static implicit operator string(int val)
{
    return "The value is: " + val.ToString(); // just an nonsense example
}

但这是错误的.编译说:

用户定义的转换必须转换为封闭类型或从封闭类型转换

我该如何解决这个问题？

我的目标是能够运行这样的代码:

int x = 50;
textbox1.Text = x; // without using .ToString() or casting

好的,我只是第一次学习模板,所以我在玩弄创建我自己的模板类,模仿它的基础类型是一个向量.请记住,对push_back的调用只调用底层向量的push_back方法.

vector<string> sV;
sV.push_back("ha");       //ok: converts from const char[3] to string

Foo<string> fS;
fS.push_back("ha");      //error: const char[3] does not match the argument list

有没有办法解决这个问题？我只是希望我的模板感觉自然就像我正在使用真实的东西一样.

编辑:这基本上是班级的主体

template <typename T> class FooPtr;
template <typename T>
class Foo{
    friend class FooPtr<T>;
public:
    Foo() {data->make_shared(vector<T>); }
#ifdef INITIALIZER_LIST
    Foo(initializer_list<T>);
#endif
    void push_back(T &t) { data->push_back(t); }
    void push_back(T &&t) { data->push_back(move(t)); }
    bool empty() { if (data->size() == 0) return true; }
    FooPtr<T> insert(size_t, T&);
    T& operator[](size_t);
    T& front();
    T& back();
    FooPtr<T> begin() { …

一些编程语言评估

5 == true

为真,或允许

if 5 then expr

将5转换为bool.

朱莉娅没有.为什么？

create table student(id int, name varchar(20));

学生表在这里创建。*

insert into student values(20,100);

在上面的查询中，我在name列中插入整数值 100 ，即varchar。为什么它没有给出错误或它是如何插入的？

编辑1：但是在插入字符串时是否需要给出单引号？前任。插入学生值（20，suraj）； 给出错误

当没有提到2D数组的行时,编译器声明"从不兼容的指针类型赋值",我一直认为没有括号的数组意味着第一个元素的地址,在这种情况下是元素的地址twodstring [0] [0]

当提到行时,编译器没有说出错误,我想知道为什么会这样？

#include<stdio.h>

int main()
{

  char onedstring[]={"1D Array"};
  char twodstring[][5]={"2D","Array"};
  char *p1,*p2;

  p1=onedstring;
  p2=twodstring;
  p2=twodstring[1];

}

当我有一个公共界面

public interface IPub { string Foo { get; set; } }

然后我可以通过显式实现这个接口:

public class CFoo : IPub { string IPub.Foo { get; set; } }

或者通过使用public修饰符隐式地:

public class CFoo : IPub { public string Foo { get; set; } }

.有道理:修饰符必须是public因为接口是public.

但是当我有一个内部接口

internal interface IInt { string Bar { get; set; } }

然后我只能明确地实现它:

public class CBar : IInt { string IInt.Bar { get; set; } }

或隐式使用public修饰符:

public class CBar …

更明确地说，编译器是否应该将true_type值视为true的第一个参数enable_if，因为true_type是真的std::integral_constant<bool, true>，并integral_constant定义了类型转换函数operator value_type？

下面是最简单的测试代码：

#include <type_traits>

template <typename T>
std::enable_if_t<std::is_pod<T>{}>
test(T)
{
}

int main()
{
    test(true);
}

它被 GCC 和 Clang 接受，但被 MSVC 拒绝（直到 Visual Studio 2019 v16.3.1）。

今天我遇到了一个意想不到的 TypeScript 编译器行为。我想知道这是一个错误还是一个功能。可能它会是最后一个，但我想知道它背后的原理。

如果我声明一个接口方法，其参数可以是 a string | number，并创建一个实现该接口的类，则该类方法只能使该参数成为string。这会导致类实现不需要数字，但编译器允许传递该数字的情况。为什么这是允许的？

interface Foo {
    hello(value: string | number): void
}

class FooClass implements Foo {
    hello(value: string) { //notice the missing 'number'
        console.log(`hello ${value}`)
    }
}

const x = new FooClass()

x.hello("me")

//x.hello(42) this gives a compile error

const y: Foo = x

y.hello(42)