Fatal编程技术网
  • types/
  • Types 转发类型声明

Types 转发类型声明

types julia

Types 转发类型声明,types,julia,Types,Julia,我想知道在julia中，是否有可能在不调用构造函数的情况下将自定义或现有类型分配给变量 类似于C++中类的前向声明。 以下是我打算实现的一个例子： type foo a end #custom type a = foo b = foo #julia type, force c to be of type Int c = Int a.a = 5.5 b.a = 4.5 c = 6 编辑以澄清我的问题： 在C++或FORTRAN中，在某个时刻声明变量以供以后使用是常见的编

我想知道在julia中，是否有可能在不调用构造函数的情况下将自定义或现有类型分配给变量

类似于C++中类的前向声明。

以下是我打算实现的一个例子：

type foo
    a
end

#custom type
a = foo
b = foo

#julia type, force c to be of type Int
c = Int    


a.a = 5.5
b.a = 4.5

c = 6
编辑以澄清我的问题：

<>在C++或FORTRAN中，在某个时刻声明变量以供以后使用是常见的编码实践。 我不记得正确的FORTRAN语法，但是在C++中，你会写一些类似的东西：

class foo;
class bar;
int a;

class foo{
private:
    bar myBar;

public:
    foo(int a){ myBar( a ); }  
}    

class bar{ 
public: 
    bar(int a){ 
        std::cout << a << std::endl;
    } 
}

a = 3;
foo( a );

foo类；
分类栏；
INTA；
福班{
私人：
我的酒吧；
公众：
foo（inta）{myBar（a）；}
}    
类条{
公众：
bar（int a）{

std:：cout在我看来，您想要做的是创建一个类型的实例，而不指定内容，然后稍后再填充。这可以通过创建一个未初始化某些字段的构造函数来实现：


type Foo
    a
    # inner constructor that leaves all fields uninitialized
    Foo() = new()
end

a = Foo()
b = Foo()

a.a = 5.5
b.a = 4.5


通过在内部构造函数中为
new
提供的参数少于type had字段，最后一个字段将变得未初始化。在为未初始化字段赋值之前读取该字段是错误的


这就是您想要的吗？
没有必要在Julia中预先声明变量，因为类型只是由用法定义的

如果要限制为某些类型，则可以执行以下操作：


type MyType
    a::Int
end


（请注意，根据惯例，类型名称的首字母大写。）

您可以在全局范围中执行变量声明，但不执行；Julia中的这些构造引入了一个新的：

语言中的某些构造引入了作用域块，这些作用域块是有资格成为某些变量集作用域的代码区域。变量的作用域不能是任意一组源代码行；相反，它将始终与这些块中的一个对齐。引入这些块的构造包括：


    

  • 函数体（任意语法）
    • 

  • while循环
    • 

  • for循环
    • 

  • 试块
    • 

  • 挡块
    • 

  • 最后阻塞
    • 

  • 让积木
    • 

  • 键入块
    • 


该列表中明显缺少的是begin块和if块，它们不引入新的作用域块

您可以选择使用：


julia>x
错误：未定义错误：x
julia>x:：Int
错误：未定义错误：x
julia>开始x结束#仍在全局范围内
错误：未定义错误：x
julia>开始x:：Int结束
错误：未定义错误：x
julia>让x结束#局部范围
朱莉娅>让x；x结束
错误：未定义错误：x


请注意，Julia将尝试将值转换为指定类型：


julia>let
x:：Int#声明变量
y:：Float64=7#转换（如果可能）
x=y#转换（如果可能）
x、 y
结束
(7, 7.0)
julia>函数foo（x，y）
x：：Int
y：：浮动64
任何
#必须有分配才能进行转换
x、 y=x，y
z=5im
x、 y，z
结束
foo（具有1个方法的泛型函数）
朱莉娅>富（3.0,7）
（3,7.0,0+5im）


编辑的示例：
定义类型/不可变。

julia>type Foo{T type Bar
x
结束
julia>不可变Baz
A.
B
C
结束


定义转换方法。

julia>import Base.convert
julia>convert{T convert（：：Type{Bar}，x）=Bar（x）
转换（具有536种方法的通用函数）
julia>convert（：：Type{Baz}，xs:：NTuple{3}）=Baz（xs…）
转换（具有537种方法的通用函数）


所以你可以这样做：

julia>let
#十重变量：
a：：Foo{Int}
b：：Foo{Float64}
c：：巴
d：：Baz
e：：Int
#赋值：
e=42
a=e
b=e
c=字符串（e）
d='a'，e，“测试”
[a、b、c、d]
结束
四元数组{Any，1}：
Foo{Int64}（42）
Foo{Float64}（42.0）
酒吧（“42”）
Baz（'a'，42，“测试”）
朱莉娅>

你能举一个你想要实现的例子吗？我看到了你的代码，但不明白它的意思和用途。一个解决方法是使用。例如，
键入foo{t}a…end
和
a=foo{Int}（）
是和否=）。这适用于自定义类型（非常好的提示btw）。但它不允许您编写：a=a:：Int。刚刚更新了我的帖子。@Vincent说“目前，类型声明不能在全局范围内使用，例如在REPL中，因为Julia还没有常量类型全局变量。”感谢您指出这一点。这已经困扰了我一段时间。在阅读文档时没有给予必要的注意。感谢您的评论。您的观点很好，但在您的示例中，您通过调用构造函数来实例化类型。我试图对编译器说“a是整数，请记住”通过定义“a=Int”。顺便说一句，我只是尝试了“a==Int”不起作用。是的，我明白了；我昨天被问到了一个类似的问题。据我所知，这在Julia中（目前）是不可能的。常量排序如下：
const a=8；a=2.5
（不同类型）给出了一个错误，而
a=17
（相同类型）只给出一个警告，并允许您使用不同的值和相同的类型重新定义值。不过，我不一定希望这种行为在Julia的未来版本中继续。（因为这里我们颠覆了
const
可能的含义。）很好的解释。谢谢。@Vincent我改进并扩展了上一个示例，我认为应该更容易看到发生了什么。有没有办法不引入一个全新的作用域就可以做到这一点？我有几个变量要在函数中使用，在整个函数中使用
let…end
块似乎有点傻re函数体。@setholopolus函数体也引入了它们自己的局部作用域，因此它应该工作（wi

b = MyType(1)
c = MyType(2)
d = MyType(3.5)  # error