标签: derived-class

我有一个基类来计算图像大小.我正在从中派生一个类,并具有将在我的代码中使用的预定义图像大小.虽然我有所作为,但我有一种强烈的感觉,我没有正确地做到这一点.

理想情况下,我想将DerviedClass.PreviewSize作为参数传递给GetWidth,而不必创建它的实例.

class Program
{
    static void Main(string[] args)
    {
        ProfilePics d = new ProfilePics();
        Guid UserId = Guid.NewGuid();

        ProfilePics.Preview PreviewSize = new ProfilePics.Preview();
        d.Save(UserId, PreviewSize);
    }
}

class ProfilePicsBase
{
    public interface ISize
    {
        int Width { get; }
        int Height { get; }
    }

    public void Save(Guid UserId, ISize Size)
    {
        string PicPath = GetTempPath(UserId);
        Media.ResizeImage(PicPath, Size.Width, Size.Height);
    }
}

class ProfilePics : ProfilePicsBase
{
    public class Preview : ISize
    {
        public int Width { get { return …

是否可以使用派生类对象访问与派生类函数具有相同签名的基类函数？这是我在下面陈述的样本..

class base1 {
public:
    void test()
    {cout<<"base1"<<endl;};
};

class der1 : public base1 {
public:
    void test()
    {cout<<"der1"<<endl;};
};

int main() {
der1 obj;
obj.test(); // How can I access the base class 'test()' here??
return 0;
}

我有这个代码:

#include <stdio.h>

class A
{
public:
    A() { printf("A::A()\n"); }
    A(const A &a) { printf("A::A(A &a)\n"); }
    A &operator=(const A &a) { printf("A::operator=\n"); }
};

class B : public A
{
public:
    B() { printf("B:B()\n"); }
    B(const A &a) : A(a) { printf("B::B(A &a)\n"); }
    B &operator=(const B &b) { printf("B::operator=\n"); }
};

int
main(int argc, char *argv[])
{
    printf(">> B b1\n");
    B b1;
    printf(">> b2 = b1\n");
    B b2 = b1;
    return 0;
}

为什么该行B b2 = …

我有一个简单的程序

$ cat a.cpp 
#include <iostream>
class MyClass {
    public:
        virtual void check() {
            std::cout << "Inside MyClass\n";
        }
};

class MyClass2: public MyClass {
    public:
        int* a;
        virtual void check() {
            std::cout << "Inside MyClass2\n";
        }
};

int main() {
    MyClass *w, *v;
    w = new MyClass2[2];
    v = new MyClass2;
    std::cout << "Calling w[0].check\n"; w[0].check();
    std::cout << "Calling v->check\n"; v->check();
    std::cout << "Calling w[1].check\n"; w[1].check();
}
$ g++ a.cpp
$ ./a.out 
Calling w[0].check
Inside MyClass2
Calling v->check
Inside …

我有以下代码.

   class A
    {
        public virtual int BoardSize { get; set; }
    }

    class B : A
    {
        public override int BoardSize
        {
            get{return 100;}
        }
    }

    Class Client
    {
        B b = new B();
        b.BoardSize = 55;
    }

在基类中,属性是可读/写的.但是在派生类中它是readonly并且应该总是返回100.虽然当我运行代码时我发现它总是按预期返回100.

但是,我不希望客户端在B类中设置BoardSize.所以它不应该允许客户端写b.BoardSize = 55.

这怎么可能？

我可以在前一段时间宣誓这个工作,当我的对象在堆上而不是在堆栈上声明时.我有一个函数,它接受一个指向基类的指针(detail :: DuplicateFn). - 虽然因为这是一个虚拟类,实际的指针是由派生类给出的(即dteail :: SkipFn)

1>GMProject.cpp(298): error C2664:
'void xml_tree<V>::combine_if<bool(__cdecl *)(const T &,const T &)>(const xml_tree<V> &,Predicate,const detail::DuplicateFn *)' :
cannot convert parameter 3 from 'detail::SkipFn (__cdecl *)(void)' to 'const detail::DuplicateFn *'

我的功能:

void GMProject::CombineTree(const pTree& Other) {
    detail::SkipFn foo();
        ProjectTree.combine_if(Other, &SimilarTreeValue<GMProject::pTree>, &foo);
}

ProjectTree.combine_if()作为第三个参数需要指向"DuplicateFn"的指针 - 而SkipFn是从DuplicateFn派生的.

如上所述,如果我在堆上声明"foo",它会正常工作(就像我期望的那样).然而,当在堆栈上声明foo时(或者-ultimatelly-使foo成为临时)它不会.这是为什么？

我是C++的初学者,我试图通过查看示例来学习它.这是一个我完全不理解其含义的类的示例定义:

class MyClass{
public:
  std::string name;
  void *data;

  MyClass(const std::string& t_name, void *t_data) : name(t_name), data(t_data) {}
};

这是我理解的:name和*data是类的变量,MyClass(...)是构造函数.意思是:左侧类派生自右侧类.但是,这部分代码的含义是什么:

MyClass(const std::string& t_name, void *t_data) : name(t_name), data(t_data) {}

以下是问题:

1. 什么是"t_data"和"t_name"？它们是"数据"和"名称"的初始值吗？这里使用t_的原因是什么？
2. 是什么意思:在上面这行？
3. 该行尾的{}是什么？

谢谢您的帮助.TJ

我知道这个问题有明确的答案:首先调用基类构造函数,然后调用派生类构造函数.

但我并不完全理解"被叫"这个词.这是否意味着构造函数的使用开始,或构造函数的使用完成？换句话说,下面的代码有两种可能的顺序:

1. BaseClass构造函数启动 - > BaseClass构造函数完成 - > DerivedClass构造函数启动 - > DerivedClass构造函数完成.

2. DerivedClass构造函数启动 - > BaseClass构造函数启动 - > BaseClass构造函数完成 - > DerivedClass构造函数完成.

哪一个应该是正确的顺序？如果1是正确的,在初始化DerivedClass实例之前,编译器如何知道调用BaseClass构造函数？

似乎案例2是正确的:"被叫"应该意味着构造函数的完成.后续问题是析构函数如何？我知道标准答案是"派生类的析构函数首先被调用".那么哪个是正确的顺序:

• DerivedClass析构函数启动
• DerivedClass析构函数完成
• BaseClass析构函数启动
• BaseClass析构函数完成

谢谢

class BaseClass {
public:
    BaseClass() {
        cout << "BaseClass constructor." << endl;
    }
};

class DerivedClass : public BaseClass {
public:
    DerivedClass() : BaseClass() {
        cout << "DerivedClass constructor." << endl;
    }
};

int main() {
    DerivedClass dc;
}

我知道很多,其他很多人已经发布了这个但是我很迷茫,因为有很多人说前向声明和其他大量令人困惑的东西我似乎无法找到一种方法来使用而不会在我的编译器中出现新的错误所以如果有人能帮助我,将非常感激.

我在Ubuntu 15.04上使用Code :: Blocks

错误是 OptimizedSurface.h|11|error: expected class-name before ‘{’ token

在OptimizedSurface Header文件中我决定这样做,class OptimizedSurface : Game{因为在此错误之前我得到了

include/Game.h|18|error: invalid use of member ‘Game::windowSurface’ in static member function 该行是optimize_surface = SDL_ConvertSurface(surface,Game :: windowSurface-> format,0);

现在代码是以下文件.

main.cpp -

#include "Game.h"
#include <stdio.h>


int main(int argc, char* args[]){
    printf("Initializing Game class\n");
    Game game = Game();
    return 0;
}

Game.h -

#ifndef GAME_H
#define GAME_H

#include "SDL2/SDL.h"
#include "SDL2/SDL_image.h"
#include <stdio.h>
#include <chrono>
#include <thread>
#include <iostream>
#include "MenuState.h"

class MenuState;

class …

*不是这个问题:在C#中调用基础构造函数*

我知道如何调用this或base链接构造函数.

即便如此,偶尔我最终会得到一个带有许多参数的基础构造函数,以及一个根本不会改变构造函数的派生类.(所有派生类正在改变虚拟方法的一些实现细节.)当发生这种情况时,我仍然需要定义派生构造函数并将所有参数传递给基础构造函数.

问题:是否有任何语法糖说"这个类没有声明它自己的构造函数,它使用了基本构造函数的精确副本."

毫无疑问,params的数量是CodeSmell,我应该尝试修复它或者创建一个ParamObject来保存它们,但这不是问题的主题.

还有很多其他方法可以解决这个问题,我特别感兴趣的是是否存在一种语法让我以这种方式解决它.