我有这样的事情:
class Bar
{
public:
pair<string,string> one;
std::vector<string> cars;
Bar(string one, string two, string car);
};
class Car
{
public:
string rz;
Bar* owner;
Car(string car, Bar* p);
};
class Foo
{
public:
Foo ( void );
~Foo ( void );
int Count ( const string & one, const string & two) const;
int comparator (const Bar & first, const Bar & second) const;
std::vector<Bar> bars;
};
int Foo::comparator(const Bar & first, const Bar & second) const{
return first.name < …main方法尝试访问var,但会导致调用模糊.为什么？无论如何,无法从静态上下文访问(可见？)Base1中的实例变量var.
class Base1 {
int var;
}
interface Base2 {
public static final int var = 0;
}
class Test extends Base1 implements Base2 {
public static void main(String args[]) {
System.out.println("var:" + var);
}
}
我正在重构大量的代码,我必须在一些函数中添加一个额外的参数,这些函数总是具有该对象成员的值.就像是
class MyClass
{
public:
CMyObject A,B;
void MyFunc(CMyObject &Object);
// used to be void MyFunc();
};
现在,我真的很想读它
class MyClass
{
public:
CMyObject A,B;
void MyFunc(CMyObject &Object = A);
};
但我不允许有一个非静态成员的默认参数.我已经读过这个类似的问题,这表明这是不可能的,但我想知道是否有任何合理的解决方法.原因是95%的时间将使用默认参数,因此使用默认参数将大大减少我必须更改的代码量.到目前为止,我最好的解决办法是这样的;
class MyClass
{
public:
CMyObject A,B;
void MyFunc(BOOL IsA = TRUE);
};
void MyClass::MyFunc(BOOL IsA)
{
CMyObject &Object = A;
if (!IsA)
Object = &B;
}
这不是很优雅,但有没有更好的方法来做到这一点,我错过了？
编辑: FWIW,额外参数的原因是从相关对象外部化一些状态相关成员以帮助多线程.
我有一个非常简单的类,我想用它作为另一个的子类.但当我把它的代码放在父类的时候,我得到:
非静态变量,不能从静态上下文引用
另一方面,当我把子GenTest类的类代码放在"父级"类代码之外时 - JavaApp1我没有得到这个错误.
public class JavaApp1 {
class GenTest {
@Deprecated
void oldFunction() {
System.out.println("don't use that");
}
void newFunction() {
System.out.println("That's ok.");
}
}
public static void main(String[] args) {
GenTest x = new GenTest();
x.oldFunction();
x.newFunction();
}
}
为什么会这样？
我有一个有趣的问题.我需要动态包装静态类.即返回一个非静态实例给我的调用者.例如:
public object CreateInstance(string className) {
Type t = assembly.GetType(className);
if (IsStatic(t)) {
return CreateStaticWrapper(t);
} else {
return Activator.CreateInstance(t);
}
}
所以我需要的是如何实现的指针CreateStaticWrapper.
注意:遗憾的是我无法使用Dynamic对象.
那么我的选择是什么？我不是那么热衷于学习IL一代吗？如果IL生成(Reflection.Emit,或者现在还有其他方法吗？)是什么方法,那么有没有人有指针？
编辑:重要的是要注意我可以返回代表词典.所以我可以使用Delegate.CreateDelegate这个,但我似乎无法解决如何处理重载方法和通用方法.
Edit2:另一种选择是使用Emit将空构造函数注入到类型中,再次指向任何指针？甚至可以在标记为静态的类型上进行此操作吗？static关键字是否会进入IL？
Edit3:对于一些上下文,我将它传递给javascript环境,请参阅: 我的项目.所以我希望能够(在JavaScript中):
var fileHelper = .create('System.IO.File');
if (fileHelper.Exists(fileName)) { fileHelper.Delete(fileName); }
谢谢大家.
std::sort在类中定义时，我无法将该函数与我的自定义比较函数一起使用。
class Test {
private:
vector< vector<int> > mat;
bool compare(vector<int>, vector<int>);
public:
void sortMatrix();
}
bool Test::compare( vector<int> a, vector<int> b) {
return (a.back() < b.back());
}
void Test::sortMatrix() {
sort(vec.begin(), vec.end(), compare);
}
我收到以下错误消息：
error: reference to non-static member function must be called
sort(vec.begin(), vec.end(), compare);
^~~~~~~
然而compare()，当我sortMatrix()在没有任何类的文件 main.cpp 中定义和时，一切正常。我将不胜感激任何帮助和建议。
可能重复:
为什么我们在内部类中没有静态方法？
我知道创建一个非静态内部类对象需要一个外部类对象,而创建的非静态内部类对象自动拥有一个对外部类对象的隐藏引用.但为什么非静态内部类不能有静态成员呢？Java设计者只需要禁止在内部类的静态方法内访问非静态外部类字段,它会更有意义,非？
如果在内部类中使用静态成员没有意义,为什么内部类可以通过继承具有静态成员的类来继承静态成员？
我也读了这篇文章.如上所述:
内部类可以继承非编译时常量的静态成员,即使它们可能不会声明它们.不是内部类的嵌套类可以根据Java编程语言的通常规则自由地声明静态成员.
这是一个惯例吗？
这是我的代码:
public class OuterClass {
private int outerClassField;
public void doSomethingOuterClass() {
outerClassField = 1;
}
public static void doSomethingStaticOuterClass() {
// outerClassField = 2; // Error: Because static method cannot access an specific object's field
}
public class InnerClass extends ClassWithStaticField {
// Error: Why a non-static inner class cannot have static fields ?
// public static int innerClassStaticField = 1;
public void doSomethingInnerClass() {
outerClassField = 3;
staticField = …C++中是否存在非静态块？
如果不是,如何优雅地模仿它？
我想替换类似的东西: -
class C{
public: void ini(){/* some code */}
};
class D{
std::vector<C*> regis; //will ini(); later
public: C field1;
public: C field2;
public: C field3; //whenever I add a new field, I have to ... #1
public: D(){
regis.push_back(&field1);
regis.push_back(&field2);
regis.push_back(&field3); //#1 ... also add a line here
}
public: void ini(){
for(auto ele:regis){
ele->ini();
}
}
};
与: -
class D{
std::vector<C*> regis;
public: C field1;{regis.push_back(&field1);}//less error-prone (because it is on-site)
public: C field2;{regis.push_back(&field2);}
public: …错误来自此行BoardState addme = new BoardState();
由于某种原因,它所指向的非静态变量是"新的".我不清楚如何修复此错误,因为新的并不意味着变量,而不是.
通过stackoverflow记录查看此错误通常来自非静态方法,该方法通常通过使方法静态或完全绕过该方法来解决.Ť
下面的代码用于引用此语句之前和之后发生的事情.
public class IntelligentTicTacToe extends TicTacToe {
public class BoardState{
public String TTTState;
public int[][] defensiveOppsArray;
public int[][] offensiveOppsArray;
public String str;
public int cnt;
}
public static ArrayList<BoardState> memory = new ArrayList<BoardState>();
public static boolean makeMove(){
char[] oArray = new char[TicTacToeArray.length];
int[][] defensiveOppsArray = new int[TicTacToeArray.length][TicTacToeArray.length];
int[][] offensiveOppsArray = new int[TicTacToeArray.length][TicTacToeArray.length];
int[][] sumOppsArray = new int[TicTacToeArray.length][TicTacToeArray.length];
//converts our Array into a String
String x = convertTTTArrayToString();
//Goes through the conditions to see …我试图理解C++中的线程,但我不知道如何解决这个问题.
我想调用两个线程来运行名为"createS"的函数,但是我得到了这个错误:
错误:无效使用非静态成员函数
我已经阅读了有关此主题的其他问题,但我真的不明白如何使我的代码有效.
有人可以解释一下我做错了什么并尝试帮助我找到解决方案吗？
test_class.cpp
void test_class::generateS(){
map1=new multimap<double,vector<int>>;
map2=new multimap<double,vector<int>>;
thread thread_1( createS, 0, nCells/2, map1 );
thread thread_2( createS, nCells/2, nCells, map2);
thread_1.join();
thread_2.join();
}
void test_class::createS(int startP, int endP, Costs *mapPointer){
//i do some stuff
}
test_class.h
void createS(int start, int end, Costs *mapPointer);
void generateS();