我真的对强类型编程语言(AKA类型安全执行)的概念感到困惑。基于维基百科来源的多个定义,我可以从我对它的理解中得出结论,类型安全实际上是关于语言本身预测的语言可以和不能做的事情(如果我错了,请纠正我)。
这让我想起了浏览一篇关于绑定的文章。这使我对静态/动态类型安全断言与字段的静态/动态绑定之间是否存在任何关系而感到困惑。
例如,一个整数变量int two = 1;被静态地绑定到它的值,试图将一个字符串值"1“赋值给整数变量会导致像int one ="1";这样的编译时错误。我认为这是一种由静态绑定实现的类型安全方法。我这样想错了吗?请启发我对这个概念的理解。
class A
{
public:
int i;
~A()
{
std::cout << "~A" << std::endl;
}
};
class B: public A
{
public:
int k;
~B()
{
std::cout << "~B" << std::endl;
}
};
int main(int argc, char* argv[])
{
A* p = new
以下代码是否以任何方式违反了C++11标准?我在2013年的VC++中得到了一个失败的断言。
class P {};
class C : public P
{
public:
virtual void a() {}
};
int main()
{
P* p = new C();
delete p;
}
失败的断言是:
File: f:\dd\vctools\crt\crtw32\misc\dbgdel.cpp
Line: 52
Expression: _BLOCK_TYPE_IS_VALID(pHead->nBlockUse)
我有一个泛型类,它帮助我检查参数值:
internal sealed class Argument<T>
where T : class
{
private void TraceAndThrow(Exception ex)
{
new InternalTraceHelper<T>().WriteError(ex);
throw ex;
}
internal void ThrowNull(object value, string argName)
{
if (Referenc
接口和类Number1,后来的Number2等等。当我尝试在方法add()中使用成员数据时,它要求我首先将它转换为类类型。但是,如果我在方法add()中使用成员方法,它并不要求我转换为类类型。如有任何解释,将不胜感激。
下面的代码附后。
package mynums;
//Interface for all my number types, Number1, Number2 (not shown), etc
public interface NumberIF
{
public int getNum();
public void setNum(int numx);
我在继承遗产方面不是很流利。我知道,如果您有A &B类,B可以从封装成A的代码中继承,但就这个问题而言,我不知道代码到底在说什么。
问题是:假设您有两个类,A和B.B继承自A,A只定义两个方法,foo() (声明为虚拟)和bar() (不是虚拟的)。这两种方法都将字母A输出到控制台。B还定义foo()和bar(),它们都将字母B输出到控制台。
以下代码的输出是什么?
B b;
A * pA = new A;
A * pA2 = &b;
b.foo(); b.bar();
pA ->foo(); pA->bar();
p
public class Sortieralgorithmen<T extends Comparable <T>>
{
public static void main (String[] args) throws IOException
{
UserInput read = new UserInput();
ArrayList<Integer> list = read.type(muster, type, length, rounds);
ArrayList<T> list =
假设我有两个基类,
struct A {};
struct B {};
以及使用多次继承的派生继承。
struct D : A, B {};
如果我的使用场景是这样的:
A *obj = new D;
也就是说,我永远不会使用B基类来引用派生对象,是否必须使两个基的析构函数都是虚拟?目前,我将B的析构函数声明为protected,禁止其他用户这样做,但这足够了吗?
那么D的析构函数呢?
静态类型化和动态类型化在堆栈溢出(例如 )上被反复询问。
协商一致意见似乎是(引用上述链接的最高答复):
如果在编译时知道变量的类型,则会静态地输入语言。
一种动态的语言:
如果类型与运行时值相关联,而不是命名变量/字段/等,则该语言是动态键入的。
Perl似乎是静态类型的(或其他静态/动态类型的常见定义)。它有3种类型:标量、数组、散列(为了简单起见忽略引用之类的东西)。类型与变量一起声明:
my $x = 10; # declares a scalar variable named x
my @y = (1, 2, 3);
感谢大家阅读,我正在尝试理解泛型,并且我得到了这篇摘录,其中我创建了一个带有泛型参数的单例。
public class Singleton<T> {
public static T getInstance() {
if (instance == null)
instance = new Singleton<T>();
return instance;
}
private static T instance = null;
}
但我得到了这样的错误:无法对非静态类型T进行静态引用
我可以使用什么作为变通方法?或者更好的是,是什么导致了这个错误?
为什么下面的代码打印"Main"?
public class Main
{
public static void method()
{
System.out.println("Main");
}
public static void main(String[] args)
{
Main m = new SubMain();
m.method();
}
}
class SubMain extends Main
{
public static void met
为什么这个程序的输出是“A类”?这不是确定为B型的吗?这不意味着这个-> g ()应该调用B类的g版本吗?
#include <iostream>
using namespace std;
class A {
private:
void g() {
cout << "CLASS A" << endl;
}
public:
virtual void f() {
g();
}
};
class B : public A {
public:
void g() {
根据JLS:
内部类是未显式或隐式声明静态的嵌套类。内部类不能声明静态初始化程序或成员接口。
但下面的代码正在成功编译。
class A {
interface B {
class C { // Inner class having static variables.
static int d; // Static variable
static {
}
}
}
}
有人能帮我理解这种行为吗?
我在将现有的.NET 3.5应用程序移植到.NET 4.0时遇到了一些问题。代码不是我自己写的,所以我不知道为什么事情是这样的。
情况是这样的:如果应用程序是从Visual Studio启动的(Release或Debug-Mode无关紧要),代码工作得很好,而且如果应用程序是从Debug-folder启动的,问题出在Release-deploy,因为从4.0 (以及4.5)开始,它不能很好地工作:-/
这是初始调用:
someObject.Text = Elements.GetElement(Int16.Parse(cb1.Text));
下面是代码:
public class Element
我有一个名为A的静态类
public static class A
{
}
还有一个名为B的类,它不是静态的:
public class B
{
}
在那之后,我将非静态类B声明为static:
public class c
{
// declare a non static class (B) as static
public static B b = new B();
}
A (静态类)和b (声明为静态类的非静态类)有什么区别?
public class BusinessObjects<O>
where O : BusinessObject
{
void SomeMethod()
{
var s = O.MyStaticMethod(); // <- How to do this?
}
}
public class BusinessObject
{
public static string MyStaticMethod()
{
return "blah";
}
}
有没有一种正确的面向对象的方法来
所以我拿回了作业,说我只有15/30分是正确的,但没有解释我错了什么问题或者为什么错了。我马上就要考试了,我想在我必须参加考试之前想办法解决这个问题。因此,我希望有人能帮助我理解我的是非?为什么?
所以我的任务是:
考虑以下Java程序:
public class Base {
public void m(Object o) { System.out.println("Base.m(Object)"); }
public static void m(String s) { System.out.println("Base.m(Str
using System;
namespace ConsoleApplication15
{
using System.Collections.Generic;
using System.Threading;
public static class Program
{
static void Main(string[] args)
{
var test1 = new Test<List<int>>();
var t = new Thread(Tester);
t.Start();
va
这些天我只是在做一些关于OOPS的头脑风暴,突然有一个问题出现在我的脑海中。我发现这是相关的,所以我决定问community.Question:
静态构造函数不能具有返回类型(int、string等),但静态方法在C#中必须具有返回类型。
c#编译器如何区分这两种情况以使其通过编译?
static Class staticClass
{
public static staticClass(){} //right
public static int staticClass(){} //wrong
public static int staticMethod(){} /
进入数据结构的子类型对象是否成为数据结构的声明类型?例如,如果我把狗对象放到哺乳动物的列表中,这些对象的类型会改变吗?
open class Mammal(str: String)
class Dog : Mammal("")
val d : Dog = Dog()
var listOfMammal: MutableList<Mammal> = mutableListOf()
listOfMammal.add(d)