当我显式地将构造函数作为参数调用时，未调用移动构造函数
当显式地将构造函数作为参数调用时，未调用移动构造函数是指在调用构造函数时，没有使用移动构造函数来创建对象的副本。
构造函数是用于创建对象的特殊成员函数，它在对象被创建时被调用。移动构造函数是一种特殊的构造函数，用于在对象的移动语义下创建对象的副本，以提高性能和效率。
在C++中，当我们显式地将构造函数作为参数调用时，通常会使用拷贝构造函数来创建对象的副本。拷贝构造函数是用于创建对象的副本的特殊成员函数。它会将一个已存在的对象的值复制到新创建的对象中。
未调用移动构造函数可能是因为以下几种情况：
- 没有定义移动构造函数：如果在类的定义中没有显式地定义移动构造函数，编译器将使用默认的拷贝构造函数来创建对象的副本。
- 不适用移动构造函数：在某些情况下，编译器可能会决定不使用移动构造函数，而是使用拷贝构造函数来创建对象的副本。这可能是因为对象的移动语义不适用于特定的情况，或者编译器认为使用拷贝构造函数更安全或更合适。
- 显式地调用拷贝构造函数：如果在显式地调用构造函数时使用了拷贝构造函数的语法，而没有使用移动构造函数的语法，那么就不会调用移动构造函数。
需要注意的是，移动构造函数通常在对象的右值语义下使用，即在对象将要被销毁或移动的情况下。它可以通过使用std::move()函数来显式地调用。
总结起来，当显式地将构造函数作为参数调用时，未调用移动构造函数可能是因为没有定义移动构造函数、不适用移动构造函数或者显式地调用了拷贝构造函数。在实际开发中，根据具体的情况选择适当的构造函数来创建对象的副本。
相关·内容
我试图通过内存控制器(实现接口simple_mem_interface)实现一个生产者(主)与内存元素(从)对话。注意:一些函数、细节和include语句在所附代码中没有完全提到。
在代码中搜索bug。添加调试工具以查找写启用端口中的错误。
binding.cpp
int sc_main(int argc, char* argv[])
{
sc_signal<unsigned int> d_out,d_in,address_d;
sc_signal<bool> wen, ren, ack;
sc_clock ClkFast("ClkFast", 10
浏览 1提问于2019-10-10得票数 0
回答已采纳
几个月前，我从c++11开始，看了“五人规则”。
所以..。我开始在每个具有虚拟析构函数的类上放置带有默认关键字的复制构造函数/复制赋值操作符/移动构造函数/移动赋值操作符。
因为规则告诉我，如果您声明显式析构函数，那么您的类就不再有它的隐式移动构造函数和移动赋值操作符了。
所以我想gcc会向我抱怨下课，因为缺少移动构造函数和移动赋值操作符。
但效果很好！发生什么事了？
class Interface {
public:
virtual ~Interface() = default; // implicit destructor
};
class ImplA : public I
浏览 7提问于2017-07-07得票数 2
回答已采纳
1回答
C++0x中的特殊成员函数
、、、、
维基百科关于的文章不包含任何关于移动构造函数和移动赋值操作符的引用。
我想更新条目，但我不知道0x标准说什么。
这两项职能的规则是什么？它们是由编译器自动生成的吗?如果是的话，何时生成？
编辑:我已经更新了维基百科的页面，如果有人喜欢的话，请帮社区编辑(如果需要的话)。
浏览 2提问于2010-07-19得票数 3
回答已采纳
2回答
我无法使用对象a3调用“显式a(字符串x)”，我得到了两个编译错误，如：
错误无效转换从'const char*‘到'int’-fpermissive初始化参数1的‘a:a(Int)’-fpermissive
我的预期输出是'int int双字符串‘；
有人能帮我排除这些错误吗？谢谢你宝贵的时间。
#include<iostream>
#include<string.h>
using namespace std;
struct a{
a(int x=0){cout<<" int ";
}
浏览 0提问于2013-02-24得票数 2
回答已采纳
我是从一个ListBox继承的。我需要显式调用基构造器吗？
public class MyListBox : ListBox
{
public MyListBox() : base()
{
}
// or
public MyListBox()
{
}
}
浏览 2提问于2012-06-04得票数 1
回答已采纳
1回答
它是怎么来的，标准没有提到once_flag的可移动性？我希望使用与std::mutex相同的参数。至少对于gcc (4.8版)来说，移动似乎被禁用了。如果某个编译器允许移动，最终可能会出现不可移植的代码。
浏览 0提问于2015-01-05得票数 3
回答已采纳
1回答
下面的代码不是用g++ 4.4.7编译的，而是在命令行上传递--std=c++0x：
#include <algorithm>
#include <iostream>
template <typename T>
class A
{
public:
T v;
A() { std::cout << "A default constructor\n"; }
A(const A& i): v(i.v) { std::cout << "A copy constructor\n"
浏览 5提问于2013-12-08得票数 4
回答已采纳
std::forward的标准签名是： template<typename T>
constexpr T&& forward(std::remove_reference_t<T>&) noexcept;
template<typename T>
constexpr T&& forward(std::remove_reference_t<T>&&) noexcept; 因为参数类型不是直接为T的，所以我们应该在使用std::forward时指定模板参数 template<typenam
浏览 29提问于2020-04-19得票数 3
我为它编写了一个PriorityQueue类和一个迭代器类。但我不明白为什么这行编译？
PriorityQueue<int,int> pq;
auto z =pq.begin();
z=nullptr;
我的意思是，迭代器不是指针(它有一个指针，但它们之间没有转换)，.How，我能阻止它吗？
编辑:开始解密：
const iterator begin() const;
浏览 2提问于2014-06-06得票数 0
回答已采纳
3回答
在从当前的中阅读有关的内容时，我可以看到以下内容：
12.8复制和移动类对象
如果类X的定义没有显式声明移动构造函数，则将隐式声明为defaulted当且仅当
-X没有用户声明的复制构造函数，
-X没有用户声明的副本赋值操作符，
-x没有用户声明的移动赋值运算符，以及
-x没有用户声明的析构函数。
注意:当未隐式声明或显式提供移动构造函数时，否则会调用移动构造函数的表达式可能会调用副本构造函数。-尾注
我认为注释部分明确提到默认移动构造函数的回退将是复制构造函数。为了理解这个概念，我编写了一个小程序来理解这个概念。
#include<iostream>
struct han
浏览 6提问于2014-10-07得票数 1
回答已采纳
根据标准，
如果类X的定义没有显式声明移动构造函数，则将隐式声明为defaulted当且仅当
-X没有用户声明的复制构造函数，
-X没有用户声明的副本赋值操作符，
-x没有用户声明的移动赋值运算符，以及
-x没有用户声明的析构函数。
现在，以下内容无法编译
# include <utility>
class Foo
{
public:
Foo() = default;
Foo(Foo const &) = delete;
};
int main()
{
Foo f;
Foo g(std::move(f)); // compilation fail
浏览 4提问于2016-05-17得票数 33
回答已采纳
请参阅下面的代码。我注释了move构造函数，而不是编译错误，现在调用了复制构造函数！尽管我使用的是std::move。
如何确保如果我使用std::move，我巨大对象永远不会调用复制构造函数(例如，我忘记添加移动构造函数)
class MyHugeObject
{
public:
MyHugeObject()
{
}
MyHugeObject(const MyHugeObject& m)
{
std::cout << "copy huge object\n";
}
// MyHugeO
浏览 0提问于2020-12-27得票数 0
2回答
我对这段代码有点困惑：
class A{
class B{
}
}
class C extends A.B{
C(A a){
a.super();
}
}
"a.super();“是什么意思？之前我认为超级链接到她的父类，但是" super ()“-链接到父类的构造函数，但实际上A类没有父类(不介意对象...)，那么在这个上下文中它意味着什么呢？
谢谢大家。
浏览 1提问于2013-07-11得票数 2
我有一个用g++.exe -std=c++20编译的代码片段
#include <iostream>
using namespace std;
class A {
public:
A() = delete;
A(int value) : value(value) {}
// A(auto &other) {
// cout << "Copy constructor called..." << endl;
// value = other.value;
// }
void operator=(co
浏览 6提问于2022-11-20得票数 0
回答已采纳
1回答
我有以下课程：
class Blub
{
public:
Blub(int value); // Not a copy constructor!
Blub(Blub&&) = default; // This line is necessary because move constructor is not added automatically
Blub& operator=(Blub&&) = default; // Does not work!?
// Disallow copy
Blub(Blub const &)
浏览 4提问于2011-09-17得票数 4
3回答
GCC并没有对我所做的一个我希望它会出错的例子说错：
class CannotBeCopied {
public:
CannotBeCopied(const CannotBeCopied&) = delete;
CannotBeCopied& operator=(const CannotBeCopied&) =delete;
CannotBeCopied() { }
~CannotBeCopied() { }
};
template<class T>
class FirstVector {
public:
First
浏览 2提问于2015-02-18得票数 0
回答已采纳
3回答
我正在运行一个静态分析工具并得到一个错误，因为没有数据成员的抽象类没有构造函数。
给定一个没有数据成员的抽象类：
class My_Interface
{
public:
virtual void interface_function(void) = 0;
};
编译器是否生成任何构造函数？
如果生成了构造函数，那么它的内容是什么？
如果生成构造函数，它是否会被优化级别所消除？
静态分析中的规则文档说：
如果没有在类中至少编写一个构造函数，编译器将默认为您编写公共构造函数。如果您没有声明至少一个构造函数，此规则将检测。
规则文档引用了Scott，“有效的C++：
浏览 1提问于2015-07-22得票数 1
回答已采纳
2回答
不可能的隐式移动操作？
、、、、
就我所理解的和而言，以下代码中的struct A不应该是可移动的，也不应该是可移动的：
#include <type_traits>
struct X {
X() noexcept; // user-declared default constructor
~X() noexcept; // Force X not to be trivially copyable
X(X &&) = delete; // Explicitly deleted move constructor
X(X const &) = delete; // Expli
浏览 3提问于2017-01-30得票数 3
回答已采纳
1回答
C++11为变量实例化/初始化提供了以下语法：
auto myClass = MyClass{};
然而，在可复制性、移动能力和赋值能力方面，类需要什么才能允许这种语法呢？
Visual studio 2013 (更新2)允许这种形式的实例化，即使复制构造函数、复制赋值操作符、移动构造函数和移动赋值运算符都已被删除，而GCC (4.7.2)只允许在默认或实现移动构造函数或未定义移动构造函数(即未删除)以及副本构造函数被默认或实现时允许实例化。
根据标准有什么要求？
浏览 4提问于2014-07-29得票数 2
回答已采纳
1回答
下面是一个小例子，它展示了一个不清楚的时刻。
struct CL
{
CL(){}
CL(int){}
explicit CL(const CL&){}
};
int main() {
CL cl1;
CL cl2=5; //(1)
CL cl3=(CL)5; //(2)
return 0;
}
CL类具有int的转换构造函数和标记为显式的复制构造函数。在(1)案例5 (int)中，隐式转换为CL，然后直接初始化cl2。在(2)情况下，cl3是复制初始化的.在这两种情况下，都必须涉及显式复制构造函数。但是不同的编译器给出
浏览 2提问于2015-09-06得票数 2
回答已采纳
class High
{
public High(String s)
{
System.out.print("From High");
}
}
public class Main extends High
{
public Main(String s)
{
System.out.print("From Low");
}
public static void main (String[] args) {
Main m=new Main("HighLow&
浏览 2提问于2021-12-03得票数 1
2回答
在C++11中，建议：
显式地定义我们自己的复制/移动构造函数，这样编译器就不会自己做(根据)。
显式声明一个参数构造函数为显式，以避免隐式转换(根据)。
在这个思路中，应该声明转换操作符explicit，以防止编译器使用它们来执行隐式转换吗？
浏览 1提问于2015-12-23得票数 1
回答已采纳
5回答
我在继承方面有点小问题。
在我的基类中，我有以下构造函数：
public Camera(string n)
{
name = n;
}
然后，在我的子类中，我有以下构造函数：
public StereoCameras(string n)
{
name = n;
}
然而，我的子类抱怨它没有包含一个接受0个参数的构造函数。我刚开始使用这样的继承，我想我已经正确地设置了我的childs构造器。
我是不是漏掉了什么？
浏览 1提问于2013-05-15得票数 1
回答已采纳
模板化的构造函数(如下所示)是否覆盖了隐式复制构造函数？
template <class T>
struct Foo
{
T data;
// ...
template <class U>
Foo(const Foo<U> &other) : data((T)doSomethingWith(other.data)) {}
// ...
};
如果是这样，如果other是通过值而不是常量引用传递的，它仍然会覆盖它吗？
如果是这样的话，有没有办法在不显式定义复制构造函数的情况下解决这个问题？
浏览 0提问于2012-06-13得票数 7
回答已采纳
2回答
在下面的代码中，派生类的move构造函数显然不会生成，尽管基类是可移动的。
#include <cstddef>
#include <memory>
#include <cstring>
#include <cassert>
template <typename T>
class unique_array : public std::unique_ptr<T[],void (*)(void*)>
{ size_t Size;
protected:
typedef std::unique_ptr<T[]
浏览 0提问于2017-12-25得票数 1
回答已采纳
4回答
#include <Fl/Enumerations.H>
class Color
{
public:
static Color amber () {return fl_rgb_color (255, 204, 0);}
static Color lighter_gray () {return fl_rgb_color (40, 40, 40); }
static Color light_gray () {return fl_rgb_color (179, 179, 179);}
static Color gra
浏览 3提问于2009-12-04得票数 1
回答已采纳
4回答
Nicolai M.Josuttis的C++标准库指出：
两者之间有一个细微的区别
X x;
Y y(x) //explicit conversion
和
X x;
Y y = x; //implicit conversion
前者通过使用类型X的显式转换来创建Y类型的新对象，而后者通过使用隐式转换来创建Y类型的新对象。
我想我对显式和隐式转换的概念有点困惑。在这两种情况下，您都是将X推送到Y本身-一个使用Y的构造函数，另一个使用赋值运算符。
在这两种情况下如何处理转换有什么不同，是什么使其显式/隐式，以及这如何与使用“显式”关键字定义的类构造函数相关联？
浏览 1提问于2011-08-18得票数 22
回答已采纳
当我学习std::move的时候，我发现了一个奇怪的问题。
如果我只添加一个对完美程序没有任何作用的析构函数，我将得到一个编译错误。
#include <iostream>
using namespace std;
class M {
public:
int database = 0;
M &operator=(M &&other) {
this->database = other.database;
other.database = 0;
return *this;
}
M(M &&oth
浏览 3提问于2016-12-06得票数 4
回答已采纳
2回答
显式默认移动构造函数
、、、、
根据c++11标准，只有在以下情况下才会生成默认的移动构造函数：
X没有用户声明的复制构造函数，X没有用户声明的副本赋值操作符，X没有用户声明的移动赋值操作符，X没有用户声明的析构函数，移动构造函数不会隐式地定义为已删除。<code>H 210</code><code>f 211</code>
我仍然可以显式地默认它吗？在嘎吱声中似乎是正确的。例如，就像这样：
class MyClass {
private:
std::vector<int> ints;
public:
MyClass(MyClass const& o
浏览 1提问于2012-06-12得票数 10
回答已采纳
在Rust中，不复制非基元类型，但默认情况下移动非基元类型。这很棒，因为复制它们的成本很高。 struct Post { title: String, content: String };
let (title, content) = ("some title".to_string(), "very long post...".to_string()); // imagine they're from the user
let post = Post { title, content };
// can longer access `title` an
浏览 20提问于2020-11-20得票数 0
2回答
我知道如果我们不声明编译器就会生成默认的构造函数。
“什么时候”才是我困惑的地方。
答：
class Base {};
int main()
{
return 0;
}
B：
class Base {};
int main()
{
Base b; // Declare a Base object.
return 0;
}
A和B的区别仅仅是B声明了一个基的真实对象。在我看来，只有当我们声明一个真实的对象而编译器没有发现任何构造函数时，它才会生成一个默认的构造函数。
我的问题是：
代码片段A会生成Base的默认构造函数吗？
有什么工具有助于检查结果吗？我
浏览 4提问于2013-10-13得票数 4
回答已采纳
在下面的代码中，我得到了标题中提到的错误。请告诉我为什么我会收到这个错误，尽管我没有在任何地方调用超类的默认构造函数MyNumber()，以及如何修复它。
package referencereturntype;
公共类MyNumber { String num；
public MyNumber(String str){
num=str;
}
public static void main (String [] args){
MyNumber my_num= new MyNumber("+2");
System.out.println("Suc
浏览 0提问于2013-10-29得票数 0
我正在使用boost::bind (Boost 1.64.0和gcc 8.3.0)来创建一个可调用的对象，并注意到一个有趣的特性--在绑定构造函数中传递一个对象，作为参数复制到一个可包装函数。即使对象是用std::move()包装的。尽管std::bind按预期工作。示例：
#include <iostream>
#include <boost/bind.hpp>
#include <functional>
class Test
{
public:
Test()
{
std::cout << "Creat
浏览 2提问于2020-04-24得票数 2
回答已采纳
我使用C++11特性来实现我自己的更小的实现，部分是为了尝试C++11各种模板。(另外，为了避免依赖于新库的麻烦，我只需要用几行代码编写，或者将较长的代码复制到自己的程序中，添加一个关于其许可的注释等等)。
我的实现似乎有效，但如果没有StrCatPiece的移动构造函数，我就无法做到这一点。这很麻烦，因为我不认为默认的移动构造函数是安全的:如果原来的StrCatPiece的piece_引用了buf_中的一个地址，那么新的StrCatPiece的piece_也将引用原始buf_中的地址，而不是新的buf_。我看不出任何保证原始缓冲区将存在，直到它不再被引用。
$ g++ --version
g
浏览 3提问于2015-12-06得票数 2
回答已采纳
#include<iostream>
#include<vector>
class Container {
int * m_Data;
public:
Container() {
//Allocate an array of 20 int on heap
m_Data = new int[20];
std::cout << "Constructor: Allocation 20 int" << std::endl;
}
~Container()
浏览 0提问于2018-03-21得票数 3
我试图了解以下结构在C++标准中的不同行为，以及对元素a和b的保证。
struct X {
int a;
int b;
};
void func() {
X x(1); // (1) Works in c++2a only
X y{1}; // (2) Works in c++1z
}
浏览 1提问于2022-03-23得票数 -3
回答已采纳
我知道下面这些都不管用，但你能帮我理解一下原因吗？
class A {
A(int x) {
System.out.println("apel constructor A");
}
}
class B extends A {
B() {
System.out.println("apel constructor B");
}
}
public class C {
public static void main(String args[]) {
B b = new B
浏览 2提问于2014-03-27得票数 4
回答已采纳
1回答
抽象类和移动语义
、、
根据“五条规则”，当我声明一个:复制或移动操作或析构函数时，我必须编写所有这些操作或析构函数，因为编译器不会为我生成它们(其中一些)。但是，如果我的类(A)来自具有虚拟析构函数的抽象类，这是否意味着类A中的析构函数将被视为“用户定义的”？因此，由于编译器不会为我生成移动构造函数，会不会使用这个类A的对象吗？
struct Interface {
virtual void myFunction() = 0;
virtual ~Interface() {};
};
struct A : public Interface {
void myFunction() overri
浏览 1提问于2015-04-23得票数 16
回答已采纳
struct copyable { // and movable
copyable() = default;
copyable(copyable const&) { /*...*/ };
copyable& operator=(copyable const&) { /*...*/ return *this; }
};
由于复制构造函数和复制分配操作函数是显式定义的，它意味着编译器不能隐式定义移动构造函数和移动分配函数，因此不允许移动操作。
你能告诉我我的上述理解是否正确吗？
浏览 1提问于2017-06-21得票数 26
回答已采纳
1回答
定义类时，下列内容是否有效？
T(const T&&) = default;
我读到了关于移动构造函数的文章，它解释了如何仍然隐式声明缺省值：
类可以有多个移动构造函数，例如T::T(const T&&)和T::T(T&&)。如果存在某些用户定义的移动构造函数，则用户仍然可以强制生成带有关键字默认值的隐式声明的move构造函数。
在页面的底部，它提到了缺陷报告CWG 2171：
CWG 2171 C++14
X(const X&&) = default是不平凡的，是微不足道的。
也许wiki条目只是一个错误，而只是
浏览 8提问于2017-01-09得票数 6
回答已采纳
如果您有一个调用this()的构造函数，何时调用super()？在第一个构造函数中调用？还是在最后一个没有关键字this()的构造函数中？
主要电话:新B()
public class A {
public A(){
System.out.print("A ");
}
}
public class B extends A {
public B(){
// is super called here? Option 1
this(1);
System.out.print("B0 ");
浏览 9提问于2022-12-03得票数 3
1回答
Intel C++编译器(版本16.0.3.207Build 20160415)在继承基类构造函数时似乎删除了显式说明符。这是个虫子吗？
struct B
{
explicit B(int) { }
};
struct D : B
{
using B::B;
};
B b = 1; // Not OK, fine
D d = 1; // Not OK with Microsoft C++ and GCC, but OK with Intel C++
浏览 8提问于2017-01-05得票数 10
回答已采纳
根据我的课本：
如果子类中任何构造函数的执行都没有调用超类构造函数，Java就会自动调用超类的无参数构造函数。
这是否意味着所有超类数据字段(超类变量)都将设置为null(因为构造函数是一个无参数的构造函数)？
浏览 2提问于2012-10-13得票数 0
回答已采纳
作为研究对象，相关代码被列出，below.You可以在上检查它。
毫无疑问，EntityId_t c_SEDSubscribe(ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER);调用the user defined constructor EntityId_t(int id)，而我认为EntityId_t c_SEDPPubWriter = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER；应该调用用户定义的构造函数EntityId_t(int id)和移动赋值操作符，但这不是这种情况，因为终止输出。换句话说，我认为ENTI
浏览 1提问于2020-06-06得票数 0
回答已采纳
如何在具有模板构造函数的类上调用make_shared或make_unique？下面是一个例子：
class A
{
/// constructor shared ptr
A(shared_ptr<X> x) ...
/// constructor that creates new shared ptr
template <class T> A() : A(make_shared<T>(...)) {}
};
make_shared<A<T>>()没有意义(它也没有编译)，因为它宁愿是模板化类，而不是
浏览 2提问于2015-12-30得票数 5
对于包含/继承类的移动构造函数的隐式生成和显式删除的构造函数的不同处理，C++11的基本原理是什么？
C++14/C++17有什么改变吗？( 中的C++14除外)
注意:我理解正在发生的事情，我理解是根据C++11标准的规则，我对这些规则的基本原理感兴趣，这些规则暗示了这种行为(请确保不要简单地重申它是这样的，因为标准是这么说的)。
假设类ExplicitDelete具有显式删除的移动ctor和显式默认副本ctor。即使兼容的副本ctor可用，该类也不是move constructible，因为重载解析选择移动构造函数，并由于删除而在编译时失败。
假设一个类ImplicitDelete，它包
浏览 3提问于2015-11-29得票数 13
回答已采纳
在下面的代码中，为什么调用F的移动ctor？
当我试图包装std::function时，我遇到了这种情况，并且惊讶地发现我的内部函子在构造过程中被移动了两次。
#include <iostream>
using namespace std;
struct F {
F() { cout << "F()" << endl; }
F(const F &) { cout << "F(const F &)" << endl; }
F(F &&) {
浏览 3提问于2016-12-02得票数 1
回答已采纳
2回答
我想创建一个包含3个值的结构:一个字符串和两个整数。该字符串是强制的，但是两个int中的一个(或两个)是可选的，如果未指定，则可以缺省为-1。
然而，与其使用struct，我想我应该尝试std::tuple。为了合并两个In的可选性，我设置了一个继承自std::tuple的"Trio“类，如下所示：
#include <string>
#include <tuple>
class Trio : public std::tuple<std::string, int, int>
{
public:
explicit Trio(std:
浏览 0提问于2013-02-21得票数 6
回答已采纳
问题是，正如我的标题所述。
我之所以这样问是因为我有一个具有默认移动构造函数的类，但是试图执行副本赋值的代码失败了，说明复制赋值操作符已被删除(根据Visual 2015)。
因此，我检查了规则是否隐式声明了复制赋值操作符：
类T的隐式声明或默认副本赋值操作符定义为已删除，在以下任一项中都是正确的：
..。
T有一个用户声明的移动构造函数。
T有一个用户声明的移动赋值操作符。
因此，基本上，我不确定默认的移动构造函数是否算为用户声明的。我的直觉告诉我，是的，但当谈到标准，我总是喜欢确定，因为假设可能是昂贵的。
浏览 2提问于2015-08-06得票数 9
回答已采纳
我试着去理解
为什么这个()和超级()不能一起使用？
我在这里阅读了许多关于堆栈溢出的相关讨论，并理解了许多事情。但我现在还有一个困惑。
在构造函数中调用this()隐式调用super()
考虑一下这段代码。
class Top
{
int z;
Top()
{
System.out.println("Top default constructor");
}
}
class A extends Top
{
int x;
A(int num)
{
x=num;
Sys
浏览 6提问于2015-01-28得票数 5
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
