为什么我不允许使用我在里面声明的变量do并在whiledo/while循环中使用它？
do
{
index += index;
int composite = index + 1;
// more code here
} while (UnsetBitmask(bitmasks, composite)); // cannot resolve symbol composite
我第一次看到这个,我认为这是一个编译器错误.所以我多次重启Visual Studio但仍然无法识别变量while.
代码有什么问题,或者这是编译器错误？
实际上,我希望有一个返回元类型的协议(例如:Type.Type),我可以传递给一个Class,然后当我需要时,将一个对象转换为该MetaType.我要强制转换它的原因是它将在tableView dequeue函数中使用,我想要转换为我指定的Type I.
考虑这个精简版(下面的完整版).
let anyObject: AnyObject = anything()
let aType = type.type() // aType here is A.Type
if let newType = anyObject as? aType {
print(newType)
}
// error: 'aType' is not a type
我很困惑为什么这不是一个类型,因为我们可以去aType.init()来初始化它？
下面是完整的示例代码(可以在Playground中运行).
import UIKit
protocol P {
func type() -> A.Type
}
class A {
}
class B: A {
}
class C: A {
}
struct BData: P {
func type() -> A.Type {
return B.self
}
}
struct Foo {
let type: P …超类变量是否可以访问子类的重写方法.例如:
class A {
void callMe() {
System.out.println("Inside A");
}
}
class B extends A {
void callMe() {
System.out.println("Inside B");
}
}
class Dispatch {
public static void main(String args[]) {
A a = new A();
B b = new B(); // Object of type B
A r; // Obtain a reference of type A
r = a; // Refers to A object
r.callMe(); // Calls A's version of callMe()
r = b; // Refers to B object
r.callMe(); …我正在做一项学术练习（为了个人成长）。我想找到一种编程语言，使您可以定义能够接受自身（即，指向自身的指针）作为参数的函数。
例如，在JavaScript中：
function foo(x, y) {
if (y === 0) return;
x(x, y - 1);
}
foo(foo, 10);
上面的代码将在y达到零之前恰好执行11次foo（），从而导致递归终止。
我尝试在OCaml中定义类似的功能，如下所示：
let rec foo x y = if y < 1 then "hi" else x x (y - 1);;
但是它失败并出现类型错误：
Error: This expression has type 'a -> 'b -> 'c
but an expression was expected of type 'a
The type variable 'a occurs inside 'a -> 'b -> 'c
我想知道，是否可以在OCaml中定义这样的功能？我对OCaml特别感兴趣，因为我知道它具有全局类型推断系统。我想知道这样的功能是否与全局类型推断兼容。因此，我正在寻找任何具有全局类型推断功能的语言的示例。
ocaml type-systems type-inference hindley-milner anonymous-recursion
静态类型VS动态类型已被要求反复的计算器，例如这里。
共识似乎是（引用以上链接的最高答案）：
如果在编译时就知道变量的类型，则语言是静态类型的。
和动态语言：
如果一种语言与运行时值关联，而不是命名为变量/字段/等，则该语言是动态类型的。
Perl似乎是通过这种方式（或静态/动态类型的其他常见定义）进行静态类型化的。它具有3种类型：标量，数组，哈希（为简单起见，忽略诸如引用之类的东西）。类型与变量一起声明：
my $x = 10; # declares a scalar variable named x
my @y = (1, 2, 3); # declares an array variable named y
my %z = (one => 1, two => 2); # declares a hash variable named z
的$，@和%上面就告诉Perl你想要的类型; 我认为这是显式键入的一种形式。
x如上所述，一旦被声明为标量，就无法在中存储非标量值x：
$x = @y; # x is now 3
将转换y为标量（在Perl中，数组到标量的转换导致数组的长度）。我将此归咎于弱类型（Perl非常自由地允许其3种类型之间进行转换），而不是动态类型。
在大多数静态类型的语言中，这样的分配将是一个错误，但是在Perl中，由于隐式转换是可以的（类似于bool x = 1;C / C ++，但在Java中则没有问题：两者都是静态类型，但是Java更强大在这种情况下键入）。这种转换在Perl中完全发生的唯一原因是因为的类型 …
客户端具有使用静态类型声明的变量 - 类似于以下测试(在VB中编译):
Dim test As System.IO.File
这样做的目的是什么？在我的客户端代码中,此变量未在任何地方引用,因此我无法遵循任何使用模式.我原以为VB会对这个声明产生问题(就像C#那样),但是因为它没有我认为有一些深奥的VB-ish目的呢？
那么，随着 C++14 中新的auto返回类型推导，有没有办法创建具有不同返回类型的函数呢？
例如：
auto replaceStr(string base, string search, string replace) {
size_t found = base.find(search);
if (found == string::npos) {
return false; //Return this is replace is not found
}
else {
base.replace(found, (found+search.length()), replace);
return base; //Return this after the replacement
}
}
我知道这行不通。那么有没有办法让它发挥作用呢？
编辑：评论中的大多数人都告诉我这是不可能的，因为编译器不知道函数在编译时的返回类型。那么也许我们可以让函数具有默认返回类型和可选返回类型？
我来自node.js，我想知道是否可以用C ++做到这一点。C ++等效于什么：
var string = "hello";
string = return_int(string); //function returns an integer
// at this point the variable string is an integer
所以在C ++中我想做这样的事情...
int return_int(std::string string){
//do stuff here
return 7; //return some int
}
int main(){
std::string string{"hello"};
string = return_int(string); //an easy and performant way to make this happen?
}
我正在使用JSON，我需要枚举一些字符串。我确实意识到我可以只将返回值分配return_int()给另一个变量，但是我想知道是否有可能为了学习和可读性而将变量的类型从字符串重新分配给int。
今天我和一位朋友讨论了静态和动态类型语言之间的差异(有关静态和动态类型语言在这个SO问题中的区别的更多信息).之后,我想知道在C++中可以使用什么样的技巧来模拟这种动态行为.
在C++中,与其他静态类型语言一样,变量类型在编译时指定.例如,假设我必须从文件中读取大量数字,这些数字在大多数情况下非常小,足够小以适应unsigned short类型.这是一个棘手的问题,少量的这些值要大得多,大到足以需要unsigned long long存储.
由于我假设我要对所有这些进行计算,我希望它们都以相同的顺序存储在相同容器中的相同容器中,而不是从输入文件中读取它们..天真的方法是将它们存储在一个vector类型中unsigned long long,但这意味着通常最多需要4倍于实际需要的空间(unsigned short2个字节,unsigned long long8个字节).
在动态类型语言中,变量的类型在运行时被解释并被强制转换为适合的类型.如何在C++中实现类似的功能？
我的第一个想法是通过指针来做,根据它的大小我会用适当的类型存储数字.这有一个明显的缺点,即必须存储指针,但是因为我认为我还是要将它们存储在堆中,我认为这不重要.
我完全相信你们中的许多人能给我提供比这更好的解决方案......
#include <iostream>
#include <vector>
#include <limits>
#include <sstream>
#include <fstream>
int main() {
std::ifstream f ("input_file");
if (f.is_open()) {
std::vector<void*> v;
unsigned long long int num;
while(f >> num) {
if (num > std::numeric_limits<unsigned short>::max()) {
v.push_back(new unsigned long long int(num));
}
else …是否可以将foo从float转换为long(反之亦然)？
auto foo = float(1234567891234.1234);
cout << "foo: " << foo << endl;
foo = long(1234567891234.1234);
cout << "foo: " << foo << endl;
输出总是:
foo: 1.23457e+12 foo: 1.23457e+12