标签: constructor

我听我的讲师说过，在 Java 中，构造函数是在主程序实际启动时调用的。但是当我尝试它时，我发现构造函数不会自动调用。代码是这样的。

class Anther {

    static void method1(){
        System.out.println("this is method");
    }

    static void method2(){
        System.out.println("this is second one");
    }

    Anther(){
        System.out.println("Anther class");
    }
    public static void main(String[] args){
        System.out.println("first line");

        method1();
        System.out.println("second line");

        method2();
        System.out.println("end of story");     
    }
}

输出是这样的

first line
this is method
second line
this is second one
end of story

为什么它没有打印“Anther class”。

我有一个隐藏默认构造函数的类,强制使用带参数的构造函数.另一个类使用该类的2个实例:

typedef struct { ... } BAZ;

class Foo {
  private:
    Foo(void) {}

  public:
    Foo(BAZ a) { ... }
};

class Bar {
  private:
    Foo foo1;
    Foo foo2;

    Bar(void) {}

  public:
    Bar(BAZ a, BAZ b) : foo1(a), foo2(b) { ... }
};

最明显的是变量foo1和foo2的声明将调用默认的Foo构造函数,但由于它是私有的,它不能并且会给编译器错误.

有没有办法阻止它尝试默认的Foo构造函数,只是等待Bar构造函数初始化它们？

我想避免使用new关键字(这将解决整个问题).

编辑:
似乎人们很难理解问题和困境.我会试着解释一下:

我想强制使用Foo(BAZ)构造函数,这意味着任何使用Foo(void)构造函数的尝试都会产生错误.

要隐藏默认构造函数,它将被声明为私有成员.如果有人试图使用默认构造函数Foo(),它将给出故意错误.

要不声明默认构造函数,只声明Foo(BAZ)不会阻止编译器创建公共默认构造函数.如果我将其声明为Foo(),则不会出错.到目前为止它的工作正常并且符合预期.

第二类Bar有两个Foo实例,但是当实例化Bar时,这些Foo成员将使用默认(隐藏)构造函数调用并生成错误.然后在Bar构造函数中,这两个实例将使用正确的公共构造函数Bar(BAZ a,BAZ b)初始化:foo1(a),foo2(b).这就是我要的.

有没有办法防止它在初始化Bar时调用Foo默认构造函数,所以Bar构造函数可以使用正确的Foo构造函数？

该新解决方案的工作,因为默认的构造函数永远不会被调用:

BAZ a = {...}
Foo *foo1 = new Foo(a);

我希望这更清楚.

EDIT2:已解决 错误不在隐藏的Foo构造函数中,它是隐藏的Bar构造函数,试图使用隐藏的默认Foo构造函数.

Bar(void) : Foo(BAZ{}), Foo(BAZ{}) {}

解决了它.

编辑3:
真正的问题似乎是在开发工具中.重新启动并手动清除缓存后,它就像C++ 14标准一样工作.

我读过，创建对象时会自动调用构造函数，但我想更深入地解释为什么它们在这方面与常规方法不同。任何示例或附加细节来说明其背后的推理将不胜感激。

我一直在使用 Java，并注意到构造函数没有返回类型，这与常规方法不同。我知道构造函数用于初始化对象，但我很好奇这种设计选择背后的具体原因。有人可以深入了解为什么 Java 构造函数没有返回类型吗？不允许构造函数指定返回类型的理由是什么？这种设计如何有助于语言的原则和一致性？

问题是关于多个让我困惑的构造函数.

#include "complex.h"
#include <iostream>

using namespace std;

Complex::Complex(double realPart, double imPart)
    : m_R(realPart), m_I(imPart)
{
    cout << "complex(" << m_R << "," << m_I << ")" << endl;
}

Complex::Complex(double realPart)
{
    Complex(realPart, 0);
}

Complex::Complex() : m_R(0.0), m_I(0.0)
{
}

int main() {
    Complex C1;
    Complex C2(3.14);
    Complex C3(6.2, 10.23);
}

有人可以解释编译器如何知道使用哪三个构造函数定义？Primer来自本书,第58页.

如果我在另一个构造函数中调用默认构造函数,它会崩溃我的程序.我相信它array_不会在默认构造函数中动态分配.我该如何解决这个问题.

template < typename T >
class Matrix
{
public :
    size_t n_{1};
    size_t m_{1};
    T* array_{nullptr};
 public  :
    Matrix();
    Matrix(size_t n, size_t m) {
        n_ = n;
        m_ = m;
        array_  = new T[n_ * m_];
        Matrix();
    }
}
template < typename T >
Matrix<T>::Matrix(){
for(int i=0;i < n_ * m_; i++)
    array_[i] = {};
}

我正在尝试这个构造函数代码,并对它的工作方式感到困惑.

#include<iostream>
using namespace std;
class XYZ{
    int a,b;
    public:
        XYZ(int i, int j):a(i), b(a*j){}
        void show(){
            cout<<a<<"\t"<<b<<"\n";
        }
};
int main(){
    XYZ X(2,3);
    X.show();
    return 0;
}

它给出了预期的结果,但是,

#include<iostream>
using namespace std;
class XYZ{
    int b,a;
    public:
        XYZ(int i, int j):a(i), b(a*j){}
        void show(){
            cout<<a<<"\t"<<b<<"\n";
        }
};
int main(){
    XYZ X(2,3);
    X.show();
    return 0;
}

出乎意料的结果.

唯一的区别是int a,b和int b,a

以及如何XYZ(int i, int j):a(i), b(a*j){}正常工作？

通过this()调用重载构造函数可能有用的一个原因是它可以防止不必要的代码重复.在许多情况下,减少重复代码会减少加载类所需的时间,因为对象代码通常较小.这对于通过因特网提供的程序尤为重要,因为加载时间是一个问题.

但是,你需要小心.调用this()的构造函数的执行速度比包含所有内联初始化代码的构造函数要慢一些.这是因为调用第二个构造函数时使用的调用和返回机制会增加开销.如果你的类只用于创建少数几个对象,或者调用this()的类中的构造函数很少被使用,那么这种运行时性能的降低可能是微不足道的.

加载课程的时间如何变小？什么应该是在构造函数中使用它和使用内联代码之间的权衡点？

头文件

#ifndef WIKI_H
#define WIKI_H

template<class T>

class Rectangle
{

    private:

        T length;
        T breadth;

        void printarea();

        public:

            Rectangle();
};

源文件

#include "Wiki.h"
#include <iostream>

using namespace std;

void Rectangle::printarea()
{

    cout<< "Area = " << length*breadth <<endl; 
}

Rectangle::Rectangle()
{

    cout<< "Enter Length" <<endl;
    cin>> lenght;
    cout<< "Enter Breadth" <<endl;
    cin>> breadth;

    printarea();
} 

主文件

#include <iostream>
#include "Wiki.h"

using namespace std;

int main()
{

    Rectangle<int>X;

    return 0;
}

所以我在一个Point类上创建了一个构造函数.

类

class Point {
public:
    Point(); //declare default constructor
    double x;
    double y;
};

构造函数

Point::Point()  {
  x=0.0;
  y=0.0;
}

现在,当我在main中打印x和y的默认值时,它们显示为0和0,这是我所期望的.

但是,只是为了好玩,将构造函数的声明更改为以下内容 -

新的构造函数声明

Point::Point()  {
  double x=0.0;
  double y=0.0;
}

现在,当我调用相同的构造函数时,我得到x和y的值分别为2.16703e-314和6.95313e-310.现在,我知道构造函数的目的.我想知道的是当我向x和y添加变量类型时,当我声明一个它开始表现得像那样的构造函数时会发生什么？希望问题很清楚.如果不是,请尽快澄清.

在 Visual Studio 2019 中，我正在尝试实现使 C++11 显示的类不可复制的技术，后来在如何使这个 C++ 对象不可复制？.

我的课是

class Foo {

public:
    Foo();
    Foo(std::string name);
    ~Foo();

    std::string m_name;

    static std::int32_t s_counter;

public:
    Foo(const Foo& inFoo) = delete;
    Foo& operator=(const Foo& inFoo) = delete;
};

定义代码是，

std::int32_t Foo::s_counter = 0;

Foo::Foo(void)
{
    Foo::s_counter++;
    std::cout << "Foo constructor.  Count = " << Foo::s_counter << std::endl;
}

Foo::Foo(std::string name)
{
    Foo::s_counter++;
    m_name = name;
    std::cout << "Foo " << m_name << " constructor.  Count = " << Foo::s_counter << …