473,320 Members | 2,041 Online
Bytes | Software Development & Data Engineering Community
Post Job

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 473,320 software developers and data experts.

Accessing virtuals in base class

Jo
Hi,

Is there a generic way to access the (virtual) functions in the base
class of a class?

Like in:

if (!this->Foo(something)) return(((Base*)this)->Foo(something)); // for
a normal member function
if (!this->Foo(something)) return(this->Base::Foo(something)); // for
a virtual member function

I would like to do this in a generic way, thus without having to put
this line in every class specifying the proper base class

Cheers,

Jo

Jun 6 '07 #1
14 1551
Jo wrote:
I would like to do this in a generic way, thus without having to put
this line in every class specifying the proper base class
How could the compiler know *which* version of the function you
want to call if you don't specify it?

Just call: Base::Foo(something);
Jun 6 '07 #2
Jo
Juha Nieminen wrote:
>Jo wrote:

>>I would like to do this in a generic way, thus without having to put
this line in every class specifying the proper base class


How could the compiler know *which* version of the function you
want to call if you don't specify it?

Just call: Base::Foo(something);
I mean the immediate base class "one up" in the inheritance tree.

That should be no problem for the compiler.

Jun 6 '07 #3
Jo wrote:
Juha Nieminen wrote:
>Jo wrote:
>>I would like to do this in a generic way, thus without having to put
this line in every class specifying the proper base class

How could the compiler know *which* version of the function you
want to call if you don't specify it?

Just call: Base::Foo(something);

I mean the immediate base class "one up" in the inheritance tree.

That should be no problem for the compiler.
no? what about this:

class A
{
public:
virtual ~A() {}
virtual void foo() { std::cout << "A::foo\n"; }
};

class B
{
public:
virtual ~B() {}
virtual void foo() { std::cout << "B::foo\n"; }
};

class C
: public A, public B
{
public:
virtual ~C() {}
virtual void foo() { std::cout << "C::foo\n"; }
};

what function should call C, given that inherits from two different
classes that define the same virtual function? On the other side, I
don't see what kind of problem do you have in specifying the base class,
when it's needed.

Regards,

Zeppe
Jun 6 '07 #4
Jo
Zeppe wrote:
Jo wrote:
>Juha Nieminen wrote:
>>Jo wrote:
I would like to do this in a generic way, thus without having to put
this line in every class specifying the proper base class

How could the compiler know *which* version of the function you
want to call if you don't specify it?

Just call: Base::Foo(something);


I mean the immediate base class "one up" in the inheritance tree.

That should be no problem for the compiler.


no? what about this:

class A
{
public:
virtual ~A() {}
virtual void foo() { std::cout << "A::foo\n"; }
};

class B
{
public:
virtual ~B() {}
virtual void foo() { std::cout << "B::foo\n"; }
};

class C
: public A, public B
{
public:
virtual ~C() {}
virtual void foo() { std::cout << "C::foo\n"; }
};

what function should call C, given that inherits from two different
classes that define the same virtual function? On the other side, I
don't see what kind of problem do you have in specifying the base
class, when it's needed.
Agreed, in this case the compiler could warn that there is ambiguity of
course. Just like the compiler does warn about ambiguity in some other
cases.

But in many cases the corresponding direct base class function should be
very definable.

But reading your answers i suppose there is no such syntax to do so..?

(though i thought to remember that i saw that somewhere)

Jun 6 '07 #5
In article <ow**********************@phobos.telenet-ops.be>,
jo@mutools.com says...

[ ... ]
I mean the immediate base class "one up" in the inheritance tree.

That should be no problem for the compiler.
....except when it is, such as when you've used multiple inheritance:

struct B1 {
virtual int foo();
};
struct B2 {
virtual inf foo();
};

struct D : B1, B2 {
void bar() {
// if we invoke foo() here, should it mean B1::foo()
// or B2::foo()?
}
};

I'm less concerned over the mechanism than your design -- why do you
want to do this in the first place? If you're doing it so often that you
need/want a way to do it conveniently/generically, that sounds to me
like you're fairly routinely creating derived classes that aren't really
substitutable for the base and overriding virtual functions in a way
that they aren't really polymorphic.

--
Later,
Jerry.

The universe is a figment of its own imagination.
Jun 6 '07 #6
Jo wrote:
Agreed, in this case the compiler could warn that there is ambiguity
of course. Just like the compiler does warn about ambiguity in some
other cases.
>
But in many cases the corresponding direct base class function should
be very definable.

it's the concept itself that is ambiguous... why for example the
previous class in the hierarchy and not the first one? And I still don't
understand why you may need this kind of syntax...
But reading your answers i suppose there is no such syntax to do so..?
no, there isn't AFAIK. It would have been a specific extension for a
specific situation that is not even a problem given that there is no
situation in which you don't have a valid alternative.
(though i thought to remember that i saw that somewhere)
I don't think so, maybe I'm wrong...

Regards,

Zeppe
Jun 6 '07 #7
Jo wrote:
:: Zeppe wrote:
::
::: Jo wrote:
:::
:::: Juha Nieminen wrote:
::::
::::: Jo wrote:
:::::
:::::
:::::: I would like to do this in a generic way, thus without having
:::::: to put this line in every class specifying the proper base
:::::: class
::::::
:::::
:::::
::::: How could the compiler know *which* version of the function
::::: you want to call if you don't specify it?
:::::
::::: Just call: Base::Foo(something);
::::
::::
:::: I mean the immediate base class "one up" in the inheritance tree.
::::
:::: That should be no problem for the compiler.
:::
:::
::: no? what about this:
:::
::: class A
::: {
::: public:
::: virtual ~A() {}
::: virtual void foo() { std::cout << "A::foo\n"; }
::: };
:::
::: class B
::: {
::: public:
::: virtual ~B() {}
::: virtual void foo() { std::cout << "B::foo\n"; }
::: };
:::
::: class C
::: : public A, public B
::: {
::: public:
::: virtual ~C() {}
::: virtual void foo() { std::cout << "C::foo\n"; }
::: };
:::
::: what function should call C, given that inherits from two
::: different classes that define the same virtual function? On the
::: other side, I don't see what kind of problem do you have in
::: specifying the base class, when it's needed.
:::
::
:: Agreed, in this case the compiler could warn that there is
:: ambiguity of course. Just like the compiler does warn about
:: ambiguity in some other cases.
::
:: But in many cases the corresponding direct base class function
:: should be very definable.

If you need to refer to the direct base class, you can add a typedef
to you class.

class C : public A, public B
{
typedef A direct_base_class; // select the one you want

public:
virtual void foo()
{
direct_base_class::foo();

// do someting more

}

};

::
:: But reading your answers i suppose there is no such syntax to do
:: so..?

No, but you can easily use existing features when needed.
Bo Persson
Jun 6 '07 #8
Jo
Zeppe wrote:
Jo wrote:
Agreed, in this case the compiler could warn that there is ambiguity
of course. Just like the compiler does warn about ambiguity in some
other cases.

But in many cases the corresponding direct base class function
should be very definable.

it's the concept itself that is ambiguous... why for example the
previous class in the hierarchy and not the first one? And I still
don't understand why you may need this kind of syntax...
But reading your answers i suppose there is no such syntax to do so..?

no, there isn't AFAIK. It would have been a specific extension for a
specific situation that is not even a problem given that there is no
situation in which you don't have a valid alternative.
(though i thought to remember that i saw that somewhere)

I don't think so, maybe I'm wrong...

OK, what i want to do is having a kind of run time type information in a
basic way:

(see the BASE word, that's what i need)

class Object { // the very base class

virtual long GetObjectType() { return(' obj'); }
bool Is(long object_type) {
return(object_type==GetObjectType()); }
virtual bool IsInSomeWay(long object_type) {
return(object_type==GetObjectType()); }
};

class Figure : public Object {

virtual long GetObjectType() { return('figr'); }
virtual bool IsInSomeWay(long object_type) { if
(GetObjectType()==object_type) return(true); else
return(BASE::IsInSomeWay(object_type)); }
};

class Rectangle : public Figure {

virtual long GetObjectType() { return('rect'); }
};

class Circle : public Figure {

virtual long GetObjectType() { return('circ'); }
};

class Ellipse : public Figure {

virtual long GetObjectType() { return('ellp'); }
};

Ellipse *e = new Ellipse;
Circle *c = e;
c->IsInSomeWay('ellp'); // returns true
c->IsInSomeWay('circ'); // returns true
c->IsInSomeWay('rect'); // returns false

So this way the exact actual object type can be recalled, but also
wether it's actually derived from another type!

Jun 6 '07 #9
Jo
Jo wrote:
Zeppe wrote:
>Jo wrote:
Agreed, in this case the compiler could warn that there is
ambiguity of course. Just like the compiler does warn about ambiguity
in some other cases.
>
But in many cases the corresponding direct base class function
should be very definable.

it's the concept itself that is ambiguous... why for example the
previous class in the hierarchy and not the first one? And I still
don't understand why you may need this kind of syntax...
But reading your answers i suppose there is no such syntax to do so..?

no, there isn't AFAIK. It would have been a specific extension for a
specific situation that is not even a problem given that there is no
situation in which you don't have a valid alternative.
(though i thought to remember that i saw that somewhere)

I don't think so, maybe I'm wrong...

OK, what i want to do is having a kind of run time type information in
a basic way:

(see the BASE word, that's what i need)

class Object { // the very base class

virtual long GetObjectType() { return(' obj'); }
bool Is(long object_type) {
return(object_type==GetObjectType()); }
virtual bool IsInSomeWay(long object_type) {
return(object_type==GetObjectType()); }
};

class Figure : public Object {

virtual long GetObjectType() { return('figr'); }
virtual bool IsInSomeWay(long object_type) { if
(GetObjectType()==object_type) return(true); else
return(BASE::IsInSomeWay(object_type)); }
};

class Rectangle : public Figure {

virtual long GetObjectType() { return('rect'); }
};

class Circle : public Figure {

virtual long GetObjectType() { return('circ'); }
};

class Ellipse : public Figure {

This must be : "class Ellipse : public Circle" of course, sorry for the typo
virtual long GetObjectType() { return('ellp'); }
};

Ellipse *e = new Ellipse;
Circle *c = e;
c->IsInSomeWay('ellp'); // returns true
c->IsInSomeWay('circ'); // returns true
c->IsInSomeWay('rect'); // returns false

So this way the exact actual object type can be recalled, but also
wether it's actually derived from another type!


Or am i on a totally wrong path here?

Maybe i should use RTTI? But isn't that taking a lot of speed/memory
resources?

It's about a realtime code working on interupt level, so it must be
steady and fast code! (e.g. no mem allocs)

Jun 6 '07 #10
Jo wrote:
Jo wrote:
>OK, what i want to do is having a kind of run time type information in
a basic way:

[CUT]

So this way the exact actual object type can be recalled, but also
wether it's actually derived from another type!

Or am i on a totally wrong path here?

Maybe i should use RTTI? But isn't that taking a lot of speed/memory
resources?

It's about a realtime code working on interupt level, so it must be
steady and fast code! (e.g. no mem allocs)
It's a interesting problem, it makes sense (at compile time you should
be able to construct such a function that returns true for a set of
values, based on the inheritance of each class) and it shouldn't require
memory allocation. I think the solution is based on template, I've tried
to sketch a solution that uses an intermediate template class that has
as arguments the Actual class (CRTP) and the parent.

#include <string>
#include <iostream>

class Figure
{
public:
virtual ~Figure() {}
virtual std::string GetName() const = 0;
virtual bool IsType(const std::string name) const { return name ==
"Figure"; }
};

template <class Parent, class Actual>
class FigureT
: public Parent
{
public:
virtual std::string GetName() const { return "Figure"; }
virtual bool IsType(const std::string name) const { return name ==
static_cast<const Actual*>(this)->Actual::GetName() ||
Parent::IsType(name); }
};
class Square
: public FigureT<Figure,Square>
{
public:
virtual std::string GetName() const { return "Square"; }
};

class Ellipse
: public FigureT<Figure,Ellipse>
{
public:
virtual std::string GetName() const { return "Ellipse"; }
};

class Circle
: public FigureT<Ellipse,Circle>
{
public:
virtual std::string GetName() const { return "Circle"; }
};
int main()
{
Square sq;
std::string type;
char* yes = "yes";
char* no = "no";
type = "Square";
std::cout << "is sq a " << type << "? " << (sq.IsType(type) ? yes : no)
<< "\n";
type = "Figure";
std::cout << "is sq a " << type << "? " << (sq.IsType(type) ? yes : no)
<< "\n";
type = "Ellipse";
std::cout << "is sq a " << type << "? " << (sq.IsType(type) ? yes : no)
<< "\n";

Ellipse el;

type = "Ellipse";
std::cout << "is el a " << type << "? " << (el.IsType(type) ? yes : no)
<< "\n";
type = "Figure";
std::cout << "is el a " << type << "? " << (el.IsType(type) ? yes : no)
<< "\n";
type = "Circle";
std::cout << "is el a " << type << "? " << (el.IsType(type) ? yes : no)
<< "\n";

Circle ci;

type = "Figure";
std::cout << "is ci a " << type << "? " << (ci.IsType(type) ? yes : no)
<< "\n";
type = "Ellipse";
std::cout << "is ci a " << type << "? " << (ci.IsType(type) ? yes : no)
<< "\n";
type = "Circle";
std::cout << "is ci a " << type << "? " << (ci.IsType(type) ? yes : no)
<< "\n";

}
I think you can start from here and improve this solution that is
somewhat messy. The concept is to implement some sort of recursion on
the function calls based on the templates arguments. With multiple
inheritance it won't work due to ambiguities... maybe it can be improved.

Regards,

Zeppe
Jun 6 '07 #11
Jo
Zeppe wrote:
Jo wrote:
>Jo wrote:
>>OK, what i want to do is having a kind of run time type information
in a basic way:

[CUT]

So this way the exact actual object type can be recalled, but also
wether it's actually derived from another type!


Or am i on a totally wrong path here?

Maybe i should use RTTI? But isn't that taking a lot of speed/memory
resources?

It's about a realtime code working on interupt level, so it must be
steady and fast code! (e.g. no mem allocs)

It's a interesting problem, it makes sense (at compile time you should
be able to construct such a function that returns true for a set of
values, based on the inheritance of each class) and it shouldn't
require memory allocation. I think the solution is based on template,
I've tried to sketch a solution that uses an intermediate template
class that has as arguments the Actual class (CRTP) and the parent.

#include <string>
#include <iostream>

class Figure
{
public:
virtual ~Figure() {}
virtual std::string GetName() const = 0;
virtual bool IsType(const std::string name) const { return name ==
"Figure"; }
};

template <class Parent, class Actual>
class FigureT
: public Parent
{
public:
virtual std::string GetName() const { return "Figure"; }
virtual bool IsType(const std::string name) const { return name ==
static_cast<const Actual*>(this)->Actual::GetName() ||
Parent::IsType(name); }
};
class Square
: public FigureT<Figure,Square>
{
public:
virtual std::string GetName() const { return "Square"; }
};

class Ellipse
: public FigureT<Figure,Ellipse>
{
public:
virtual std::string GetName() const { return "Ellipse"; }
};

class Circle
: public FigureT<Ellipse,Circle>
{
public:
virtual std::string GetName() const { return "Circle"; }
};
int main()
{
Square sq;
std::string type;
char* yes = "yes";
char* no = "no";
type = "Square";
std::cout << "is sq a " << type << "? " << (sq.IsType(type) ? yes
: no) << "\n";
type = "Figure";
std::cout << "is sq a " << type << "? " << (sq.IsType(type) ? yes
: no) << "\n";
type = "Ellipse";
std::cout << "is sq a " << type << "? " << (sq.IsType(type) ? yes
: no) << "\n";

Ellipse el;

type = "Ellipse";
std::cout << "is el a " << type << "? " << (el.IsType(type) ? yes
: no) << "\n";
type = "Figure";
std::cout << "is el a " << type << "? " << (el.IsType(type) ? yes
: no) << "\n";
type = "Circle";
std::cout << "is el a " << type << "? " << (el.IsType(type) ? yes
: no) << "\n";

Circle ci;

type = "Figure";
std::cout << "is ci a " << type << "? " << (ci.IsType(type) ? yes
: no) << "\n";
type = "Ellipse";
std::cout << "is ci a " << type << "? " << (ci.IsType(type) ? yes
: no) << "\n";
type = "Circle";
std::cout << "is ci a " << type << "? " << (ci.IsType(type) ? yes
: no) << "\n";

}
I think you can start from here and improve this solution that is
somewhat messy. The concept is to implement some sort of recursion on
the function calls based on the templates arguments. With multiple
inheritance it won't work due to ambiguities... maybe it can be improved.
Thanks Zeppe.

You're thinking creatively :)

But to be honnest, the work that i should do to implement this with
templates is much more than the work i just wanted to spare out by
"automatically" refering to the direct base class.

So, for now, i think i'll stick with explicitly writing the
'BaseClass::' thing all the time...

And i'll think your idea over.

Cheers,

Jo

Jun 6 '07 #12
Jo
Jo wrote:
Zeppe wrote:
>Jo wrote:
>>Jo wrote:

OK, what i want to do is having a kind of run time type information
in a basic way:

[CUT]

So this way the exact actual object type can be recalled, but also
wether it's actually derived from another type!

Or am i on a totally wrong path here?

Maybe i should use RTTI? But isn't that taking a lot of speed/memory
resources?

It's about a realtime code working on interupt level, so it must be
steady and fast code! (e.g. no mem allocs)

It's a interesting problem, it makes sense (at compile time you
should be able to construct such a function that returns true for a
set of values, based on the inheritance of each class) and it
shouldn't require memory allocation. I think the solution is based on
template, I've tried to sketch a solution that uses an intermediate
template class that has as arguments the Actual class (CRTP) and the
parent.

#include <string>
#include <iostream>

class Figure
{
public:
virtual ~Figure() {}
virtual std::string GetName() const = 0;
virtual bool IsType(const std::string name) const { return name
== "Figure"; }
};

template <class Parent, class Actual>
class FigureT
: public Parent
{
public:
virtual std::string GetName() const { return "Figure"; }
virtual bool IsType(const std::string name) const { return name
== static_cast<const Actual*>(this)->Actual::GetName() ||
Parent::IsType(name); }
};
class Square
: public FigureT<Figure,Square>
{
public:
virtual std::string GetName() const { return "Square"; }
};

class Ellipse
: public FigureT<Figure,Ellipse>
{
public:
virtual std::string GetName() const { return "Ellipse"; }
};

class Circle
: public FigureT<Ellipse,Circle>
{
public:
virtual std::string GetName() const { return "Circle"; }
};
int main()
{
Square sq;
std::string type;
char* yes = "yes";
char* no = "no";
type = "Square";
std::cout << "is sq a " << type << "? " << (sq.IsType(type) ? yes
: no) << "\n";
type = "Figure";
std::cout << "is sq a " << type << "? " << (sq.IsType(type) ? yes
: no) << "\n";
type = "Ellipse";
std::cout << "is sq a " << type << "? " << (sq.IsType(type) ? yes
: no) << "\n";
Ellipse el;

type = "Ellipse";
std::cout << "is el a " << type << "? " << (el.IsType(type) ? yes
: no) << "\n";
type = "Figure";
std::cout << "is el a " << type << "? " << (el.IsType(type) ? yes
: no) << "\n";
type = "Circle";
std::cout << "is el a " << type << "? " << (el.IsType(type) ? yes
: no) << "\n";
Circle ci;
type = "Figure";
std::cout << "is ci a " << type << "? " << (ci.IsType(type) ? yes
: no) << "\n";
type = "Ellipse";
std::cout << "is ci a " << type << "? " << (ci.IsType(type) ? yes
: no) << "\n";
type = "Circle";
std::cout << "is ci a " << type << "? " << (ci.IsType(type) ? yes
: no) << "\n";
}
I think you can start from here and improve this solution that is
somewhat messy. The concept is to implement some sort of recursion on
the function calls based on the templates arguments. With multiple
inheritance it won't work due to ambiguities... maybe it can be
improved.


Thanks Zeppe.

You're thinking creatively :)

But to be honnest, the work that i should do to implement this with
templates is much more than the work i just wanted to spare out by
"automatically" refering to the direct base class.

So, for now, i think i'll stick with explicitly writing the
'BaseClass::' thing all the time...

And i'll think your idea over.

To be honnest, the more i think about this, the more i'm surprised that
this is not in the C++ standard.

Being able to refer to the first parent base class in an abstract way
(e.g. this->_bass::foo or ((_base)this)->foo) definitely improves an OO
construction!

If you change the class hierarchy, now you may have to update all
references to the parent base class manually!!

Jun 6 '07 #13
Jo wrote:
>
To be honnest, the more i think about this, the more i'm surprised that
this is not in the C++ standard.

Being able to refer to the first parent base class in an abstract way
(e.g. this->_bass::foo or ((_base)this)->foo) definitely improves an OO
construction!
As I told you, such a construct would be too specific for a problem, it
would create problem with multiple inheritance, and it could be
replicated with a little template. In my view, the biggest problem with
your construct is that it should refer to the _first_ parent in the
hierarchy. Why the first? I think there is no such a strong concept of
first parent in c++ that can justify such an operator.
If you change the class hierarchy, now you may have to update all
references to the parent base class manually!!
Not with the method that i suggested you. If you don't want to implement
it, it's another story ;)

Anyway, probably you won't change the class hierarchy so often...

Regards,

Zeppe
Jun 6 '07 #14
Jo
zeppe wrote:
Jo wrote:
>>
To be honnest, the more i think about this, the more i'm surprised
that this is not in the C++ standard.

Being able to refer to the first parent base class in an abstract way
(e.g. this->_bass::foo or ((_base)this)->foo) definitely improves an
OO construction!


As I told you, such a construct would be too specific for a problem,
it would create problem with multiple inheritance, and it could be
replicated with a little template. In my view, the biggest problem
with your construct is that it should refer to the _first_ parent in
the hierarchy. Why the first? I think there is no such a strong
concept of first parent in c++ that can justify such an operator.

Just to be clear: with the first parent class i mean the class of which
explicitly is derived from. I don't mean the root base class.

The possible ambiguity in certain situations (e.g. multiple inheritance)
is not a big problem.

It's at the same problematic level as having ambiguous overloaded
functions: the compiler warns you, and you resolve it. Not a big problem.

I would suggest something analog here.
>If you change the class hierarchy, now you may have to update all
references to the parent base class manually!!
Not with the method that i suggested you. If you don't want to
implement it, it's another story ;)

Hey Zeppe, i believe it could be a nice technical solution, definitely
creative!

But the bad thing with templates is that they make the code harder to
read, more complex, and that's something i always try to avoid.

Keeping things as simple as possible. (but using complexity where really
necessary)

Anyway, i did not yet decide wether or not to use your method, i'll give
it some further thought...
Anyway, probably you won't change the class hierarchy so often...

Mmm, ... not sure about that.

And it's also about the OO principle of encapsulation: being able to
refer to the immediate base class of a class in a generic way would make
things more abstract, while constructively OK.

Anyway, if it's not in the syntax, then i'll have to live with it.
Nothing is perfect.

Thanks again,

Jo

Jun 6 '07 #15

This thread has been closed and replies have been disabled. Please start a new discussion.

Similar topics

6
by: Abhijit Deshpande | last post by:
Is there any elegant way to acheive following: class Base { public: Base() {} virtual ~Base() {} virtual void Method() { cout << "Base::Method called"; return; } };
2
by: Simon White | last post by:
Hi, I have code that looks legal to me and has compiled for years and on latest VC, etc compilers. Just recently gcc made a change to their compiler (3.4) that broke it. I don't have access to...
2
by: Steven T. Hatton | last post by:
I find the surprising. If I derive Rectangle from Point, I can access the members of Point inherited by Rectangle _IF_ they are actually members of a Rectangle. If I have a member of type Point...
5
by: Siva | last post by:
Hello I have a dropdownlist inside the gridview as a template column defined as follows: <asp:TemplateField HeaderText="Choose Location"> <ItemTemplate> <asp:DropDownList ID="ddlChooseLoc"...
2
by: Jessica | last post by:
I have a base class and a derived class, but I am getting errors when I try to access functions of the derived class. Simplified version of my code is as follows: //////////////// // test2.hh...
6
by: greek_bill | last post by:
Hi, I'm interested in developing an application that needs to run on more than one operating system. Naturally, a lot of the code will be shared between the various OSs, with OS specific...
4
by: Angus | last post by:
I have a base class which has a function GetThingID which returns a integer value. The ctor of the base class sets the value. In my derived class I want to use this function GetThingID. I have...
6
by: Bhawna | last post by:
I am into c++ code maintenance for last 3-4 years but recently I am put into design phase of a new project. Being a small comapany I dont have enough guidance from seniors. Currently I am into a...
1
by: nsphelt | last post by:
I am wondering if it is possible to access the underlying property of a base class within a derived that has overridden that property. I am using VB.NET and when I use the MyBase keyword to access...
0
by: DolphinDB | last post by:
Tired of spending countless mintues downsampling your data? Look no further! In this article, you’ll learn how to efficiently downsample 6.48 billion high-frequency records to 61 million...
0
isladogs
by: isladogs | last post by:
The next Access Europe meeting will be on Wednesday 6 Mar 2024 starting at 18:00 UK time (6PM UTC) and finishing at about 19:15 (7.15PM). In this month's session, we are pleased to welcome back...
1
isladogs
by: isladogs | last post by:
The next Access Europe meeting will be on Wednesday 6 Mar 2024 starting at 18:00 UK time (6PM UTC) and finishing at about 19:15 (7.15PM). In this month's session, we are pleased to welcome back...
0
by: jfyes | last post by:
As a hardware engineer, after seeing that CEIWEI recently released a new tool for Modbus RTU Over TCP/UDP filtering and monitoring, I actively went to its official website to take a look. It turned...
0
by: ArrayDB | last post by:
The error message I've encountered is; ERROR:root:Error generating model response: exception: access violation writing 0x0000000000005140, which seems to be indicative of an access violation...
0
by: CloudSolutions | last post by:
Introduction: For many beginners and individual users, requiring a credit card and email registration may pose a barrier when starting to use cloud servers. However, some cloud server providers now...
1
by: Shællîpôpï 09 | last post by:
If u are using a keypad phone, how do u turn on JavaScript, to access features like WhatsApp, Facebook, Instagram....
0
by: af34tf | last post by:
Hi Guys, I have a domain whose name is BytesLimited.com, and I want to sell it. Does anyone know about platforms that allow me to list my domain in auction for free. Thank you
0
isladogs
by: isladogs | last post by:
The next Access Europe User Group meeting will be on Wednesday 3 Apr 2024 starting at 18:00 UK time (6PM UTC+1) and finishing by 19:30 (7.30PM). In this session, we are pleased to welcome former...

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.