есть файл хедер:

#pragma once
class element1{
public:
    virtual float GetCurrent(float Potential1, float Potential2,float frequency); 
    virtual float GetVoltage(float Current,float frequency);
};

class  resistive: public element1{
float value_of_resistive;
resistive(float value);
};

и есть собственно файл с кодом

#include "stdafx.h"
resistive::resistive(float value){value_of_resistive = value;}
resistive::GetCurrent(float Potential1, float Potential2,float frequency){return 0;}

float element1::GetCurrent(float Potential1, float Potential2,float frequency){return 0;}; 
float element1::GetVoltage(float Current,float frequency){return 0;};

в результате ругается на "resistive::GetCurrent(float Potential1, float Potential2,float frequency){return 0;}" функция не определена в хэдаре, но как я понимаю мы наследуемся от element1 и его функции нам доступны, если они определены как virtual мы можем их переопределить для нового класса...

и еще если из файла с кодом убрать:

float element1::GetCurrent(float Potential1, float Potential2,float frequency){return 0;}; 
float element1::GetVoltage(float Current,float frequency){return 0;};

то он ругается что функции не определены, хотя ни одного экземпляра данного класса не используется в программе.
Что я не правильное делаю? или что я не до понимаю?

Наследование, примененное вместо агрегации, группой лиц по предварительному сговору.
Предлагаю ввести закон это карающий.

Здравствуйте, TimurSPB, Вы писали:

TSP>Наследование, примененное вместо агрегации, группой лиц по предварительному сговору.
TSP>Предлагаю ввести закон это карающий.

Здравствуйте, Аноним, Вы писали:

А> есть файл хедер:
А>#pragma once
А>class element1{
А>public:
А> virtual float GetCurrent(float Potential1, float Potential2,float frequency);
А> virtual float GetVoltage(float Current,float frequency);
А>};

А>class resistive: public element1{
А>float value_of_resistive;
А>resistive(float value);
А>};

А>и есть собственно файл с кодом


А>#include "stdafx.h"
А>resistive::resistive(float value){value_of_resistive = value;}
А>resistive::GetCurrent(float Potential1, float Potential2,float frequency){return 0;}
Здесь еще должно ругаться что нет типа возврата функции (float)

А>float element1::GetCurrent(float Potential1, float Potential2,float frequency){return 0;};
А>float element1::GetVoltage(float Current,float frequency){return 0;};

А>в результате ругается на "resistive::GetCurrent(float Potential1, float Potential2,float frequency){return 0;}" функция не определена в хэдаре, но как я понимаю мы наследуемся от element1 и его функции нам доступны, если они определены как virtual мы можем их переопределить для нового класса...

Да можем, но обязаны сделать объявку в хедере для добавки в vtable

А>и еще если из файла с кодом убрать:
А>float element1::GetCurrent(float Potential1, float Potential2,float frequency){return 0;};
А>float element1::GetVoltage(float Current,float frequency){return 0;};
А>то он ругается что функции не определены, хотя ни одного экземпляра данного класса не используется в программе.
А> Что я не правильное делаю? или что я не до понимаю?

Правильно ругается ... он же должен знать где находится имплементация витуальных функций базового класса чтобы впихнуть в vtable соответствующий адрес

Здравствуйте, Аноним

#include "stdafx.h"
#include <assert.h>
//{{interface IElement
class IElement
{
    public: virtual float GetCurrent(float _potential1 = 0, float _potential2 = 220, float _frequency = 50) = 0;
    public: virtual float GetVoltage(float _current = 220,float _frequency = 50) = 0;
};
//}}interface IElement

//{{implementation of interface IElement
class CElement: public IElement
{
    public: CElement(){}//can't be virtual
    public: virtual ~CElement(){}
    //changing default parameters! defined in IElement
    public: float GetCurrent(float _potential1 = 10, float _potential2 = 250, float _frequency = 60);
    public: float GetVoltage(float _current = 250,float _frequency = 60);
};
//}}implementation of interface IElement

//{{override GetCurrent of interface IElement in child
class CResistive: public CElement{
    private: float m_value;
    public: float GetValue(){return m_value;}
    //--------------------
    public: CResistive(float _value = 1):m_value(_value){}
    public: virtual ~CResistive(){}
    //--------------------
    public: float GetCurrent(float _potential1 = 30, float _potential2 = 350, float _frequency = 70);
};
//}}override GetCurrent of interface IElement in child

//{{definitions
float CElement::GetCurrent(float _potential1, float _potential2, float _frequency)
    {return _potential1+_potential2+_frequency;}
float CElement::GetVoltage(float _current,float _frequency)
    {return _current + _frequency;}
float CResistive::GetCurrent(float _potential1, float _potential2, float _frequency)
    {return -_potential1-_potential2-_frequency;}
//}}definitions

int _tmain(int argc, _TCHAR* argv[])
{
    CResistive rs(10);
    float current1 = (&rs)->GetCurrent(rs.GetValue());
    float current2 = ((CElement*)&rs)->GetCurrent(rs.GetValue());
    float current3 = ((IElement*)&rs)->GetCurrent(rs.GetValue());
    assert(current1!=current2);
    assert(current2!=current3);
    assert(current1!=current3);
    return 0;
}

PS: Учебники никто не отменял.

Здравствуйте, F3V, Вы писали:

F3V>Здравствуйте, Аноним

...

Да, Java косит наши ряды

Здравствуйте, Аноним, Вы писали:

А> Что я не правильное делаю? или что я не до понимаю?

Ну хотя бы так можно написать

#include <memory>
#include <cstdio>

class element
{
public:
  virtual float GetCurrent(float Potential1, float Potential2,float frequency);
  virtual float GetVoltage(float Current,float frequency);
  
  virtual ~element() { }
};

class resistive: public element
{
  float value_of_resistive;
  
public:
  resistive(float value);
  virtual float GetCurrent(float Potential1, float Potential2,float frequency);
};

resistive::resistive(float value)
{
  value_of_resistive = value;
}

float resistive::GetCurrent(float Potential1, float Potential2,float frequency)
{
  return 25.0f * value_of_resistive;
}

float element::GetCurrent(float Potential1, float Potential2,float frequency)
{
  return 0.0f;
}

float element::GetVoltage(float Current,float frequency)
{
  return 0.0f;
}

int main(int argc, char** argv)
{
  std::auto_ptr<element> elem(new resistive(2.5f));
  std::printf("%f\n", elem->GetCurrent(0.0, 0.0, 0.0));
  return 0;
}

Не бог весть что, но читабельно и работает.
Если по пунктам:
1. Объявлять тип возврата из функции обязательно, assume int давно отменили
2. Если делаем перегрузку, объявляем её в классе-потомке
3. Неплохо бы не забывать про виртуальные деструкторы