C ++中的struct和class有什么区别?


439

这个问题已经在C#/。Net上下文中提出过

现在,我想学习C ++中的结构和类之间的区别。请讨论技术差异以及在OO设计中选择一个或另一个的原因。

我将从一个明显的区别开始:

  • 如果不指定public:private:,则默认情况下结构的成员是公共的;默认情况下,类的成员是私有的。

我确信在C ++规范的晦涩之处可以找到其他差异。


6
链接很好地总结了差异。
sjsam 2015年

1
那么为什么人们都使用struct来构建一棵树?因为似乎差异不大。顺便说一句,是一个很棒的网站。@ sjsam
JW.ZG

1
寻找structC和C ++ 之间的区别?看这里
Marc.2377

@“ JW.ZG”不是“所有”人!那些这样做的人要么只是喜欢,要么没有意识到structC ++的含义。;)但是没有理由您不能使用该class关键字。
Lightness Races in Orbit,

Answers:


465

您会忘记类和结构之间的棘手的第二个区别。

符合标准(从C ++ 98到C ++ 11,第11.2.2节):

在不存在的访问说明符 为基类,当派生的类声明,假定公共 结构和私人当假设所述类被声明

出于完整性考虑,在(11.2)中定义了class和struct之间更广为人知的区别:

默认情况下,用关键字class定义的类的成员私有的。默认情况下,使用关键字structunion定义的类的成员 是公共的。

附加区别:关键字class可用于声明模板参数,而struct关键字不能如此使用。


22
这并不是第二个差异,只是问题未完全说明差异。所有子对象使用时,在默认情况下私人class,默认情况下与公众struct,都定义一个类类型。
Ben Voigt

10
我想你错了,本。对于结构,是公共的,对于类,是私有的。这是一个非常重要的区别,与实际的成员访问权限完全无关。例如,该语言很可能以其他方式定义了它,例如默认情况下两者都是公开继承的,您将获得截然不同的含义。
阿萨夫·拉维

104
实际上,和之间真正的棘手区别是后者可以代替a 来声明模板参数,而前者则不能。structclasstypename:)
2012年

21
@MrUniverse:这是完全错误的。(有一所学校将其用作惯例,但并未在语法上强制执行。)
sbi 2013年

3
@sbi“结构和类之间的真正棘手的差异” -可爱的,但问题是有关的区别一个结构和类,不是在可以使用的关键字的差异。
Jim Balter 2015年

161

引用C ++常见问题解答

[7.8]关键字struct和class有什么区别?

结构的成员和基类默认情况下是公共的,而在类中,它们默认是私有的。注意:应将基类显式设置为公共,私有或受保护,而不要依赖默认值。

结构和类在功能上是等效的。

好的,足够的干净利落的技术讨论。从情感上讲,大多数开发人员在类和结构之间做出强烈区分。结构只是感觉像是一堆开放的位,几乎没有封装或功能性的方式。班级感觉像是一个有活力的社会成员,拥有智能的服务,强大的封装障碍和明确定义的界面。因为这是大多数人已经拥有的含义,所以如果您有一个方法很少且具有公共数据的类(这种情况确实存在于设计良好的系统中!),则应该使用struct关键字,否则,您可能应该使用该类关键词。


123

值得记住C ++的起源以及与C的兼容性。

C具有结构,没有封装的概念,因此所有内容都是公共的。

默认情况下,默认情况下公开公开是在采用面向对象方法时的一个坏主意,因此在制作一种本来有利于OOP的C形式(您可以在C中进行OO,但无济于事)时,在C ++中(最初是“带有类的C”)的想法,默认情况下将成员设为私有是有意义的。

另一方面,如果Stroustrup更改了的语义,struct从而默认情况下其成员为私有,则兼容性将受到破坏(随着标准的不同,这种情况不再常见,但是所有有效的C程序也是有效的C ++程序,这对C ++的立足点有很大的影响)。

因此class引入了一个新关键字,它与结构完全一样,但默认情况下为private。

如果C ++是从头开始的,没有历史,那么它可能只有一个这样的关键字。它也可能不会产生影响。

通常,人们在进行诸如在C语言中使用结构的操作时会倾向于使用struct。公共成员,没有构造函数(只要不是联合体,就可以在结构中构造构造函数(就像使用类一样,但人们通常不会这样做)),没有虚拟方法等。人们阅读代码以指示机器(否则我们会坚持使用汇编程序和原始VM操作码),那么坚持下去是个好主意。


可能还值得注意的是,使类和结构在后台完全相同可能比使它们在根本上有所不同要容易得多。回顾一下可能会有一些好处,例如,指定任何声明为struct的东西都必须是PODS(即,禁止具有虚拟成员,非平凡的默认构造函数或析构函数等的结构),但据我所知任何C ++标准或实现都未曾要求过。
2013年

1
@supercat这是一种OO语言,其中大量用非OO语言编写的程序都是有效程序,这使这一概念脱颖而出,而且与纯OO语言相比,它的出现确实更多。 (当然是在标准中实际定义的)。早期C ++的历史肯定解释了很多。Stroustrup的“ C ++的设计与演化”是一本有趣的文章。
乔恩·汉纳

1
我认为人谁觉得一切是不是“接力十岁上下的”,应该是之间的宗教战争,如果谁认为OOP应被视为一个工具,但不是工具。C ++似乎确实接受了后者的哲学,但是在此之前我对语言真的并不了解。我自己的哲学是,当一个人想要一个对象时,应该使用一个对象,而当一个人想要聚合相关但独立的变量时,则应该使用该对象。C ++在这些类型的东西之间没有语法上的区别,.NET试图模糊这种区别,但是我对D的了解很少...
supercat 2013年

1
...建议它比C ++或.NET更能识别它。变量的集合并不完全是OOPish,但这并不意味着在有用时就不应使用它们。
2013年

3
我不同意“ C具有结构,它没有封装的概念,因此所有内容都是公共的。”,您可以隐藏-File struct内部的定义,*.c并让其他翻译单元仅将其与指针一起使用。因此,您拥有更强大的封装,因为其他翻译单位甚至都不知道struct
12431234123412341234123 '17年

32

默认情况下,班级成员是私人的。默认情况下,Struct的成员是公开的。除此之外,没有其他差异。也看到这个问题


15
不仅是成员,而且包括继承在内的所有访问权限。
Nemanja Trifunovic

4
好吧,我想说另一个区别是语义。结构来很多人,使他们认为“数据结构”从C的剩余
克里斯Kumler

3
@KrisKumler:这些不是“语义学”;他们是个人的感觉。二者structclass声明一个具有相同的语义(尽管定义体的解析明智解释)。
Lightness Races in Orbit

28

根据Stroustrup的C ++编程语言

您使用哪种样式取决于环境和品味。我通常更喜欢将struct所有数据公开的类。我认为此类是“不是很恰当的类型,只是数据结构”。

在功能上,除了公共/私人之外没有其他区别


32
有什么区别?请解释。
crashmstr

10

STRUCT是一种抽象数据类型,它根据结构规范划分给定的内存块。结构在文件序列化/反序列化中特别有用,因为结构经常可以逐字写入文件中。(即获取指向该结构的指针,使用SIZE宏计算要复制的字节数,然后将数据移入或移出该结构。)

类是尝试确保信息隐藏的另一种抽象数据类型。在内部,可以有各种各样的机器,方法,临时变量,状态变量。等等,这些都用于向希望使用该类的任何代码提供一致的API。

实际上,结构与数据有关,类与代码有关。

但是,您确实需要了解这些仅仅是抽象。完全有可能创建看起来像类的结构以及看起来像结构的类。实际上,最早的C ++编译器只是将C ++代码转换为C的预编译器。因此,这些抽象对逻辑思维有利,而对计算机本身却不一定是一种资产。

除了每个都是不同类型的抽象这一事实之外,类还为C代码命名难题提供了解决方案。由于不能公开多个具有相同名称的函数,因此开发人员通常会遵循_()模式。例如mathlibextreme_max()。通过将API分组为类,可以将相似的函数(这里称为“方法”)组合在一起,并防止其他类中方法的命名。这使程序员可以更好地组织代码并增加代码重用。从理论上讲,至少。


1
这是关于结构和类的最不明显的事情。“结构是关于数据的,类是关于代码的”可以改写为“结构是关于数据的,类是关于数据的,安全性以及对此数据执行的操作”
Arun Aravind 2014年

3
无法在C ++中创建结构。仅可以使用Inherited struct关键字创建一个类。
Lightness Races in Orbit

1
这个答案似乎与C ++无关。在C ++中,struct声明类(包括public/ private/ protected,继承等)。
melpomene

结构如何抽象?即使在C语言中,将原始结构写入文件也充满了问题(通常的问题包括填充,字节序,不同的字长等)。SIZE您在说什么这个宏?
melpomene

10

1)默认情况下,类的成员是私有的,而struct的成员是公共的。

例如,程序1编译失败,程序2运行正常。

// Program 1
#include <stdio.h>

class Test {
    int x; // x is private
};
int main()
{
  Test t;
  t.x = 20; // compiler error because x is private
  getchar();
  return 0;
}
Run on IDE
// Program 2
#include <stdio.h>

struct Test {
    int x; // x is public
};
int main()
{
  Test t;
  t.x = 20; // works fine because x is public
  getchar();
  return 0;
}

2)从类/结构派生结构时,基类/结构的默认访问说明符是公共的。当派生一个类时,默认的访问说明符是私有的。

例如,程序3编译失败,程序4运行正常。

// Program 3
#include <stdio.h>

class Base {
public:
    int x;
};

class Derived : Base { }; // is equilalent to class Derived : private Base {}

int main()
{
  Derived d;
  d.x = 20; // compiler error becuase inheritance is private
  getchar();
  return 0;
}
Run on IDE
// Program 4
#include <stdio.h>

class Base {
public:
    int x;
};

struct Derived : Base { }; // is equilalent to struct Derived : public Base {}

int main()
{
  Derived d;
  d.x = 20; // works fine becuase inheritance is public
  getchar();
  return 0;
}

我删除了专家提到的代码示例3-7
Suraj K Thomas

8

唯一的不同是类和结构的默认继承,毫不奇怪,它们分别是私有和公共的。


5
  1. 默认情况下,结构的成员是公共的,而默认情况下,类的成员是私有的。
  2. 从另一个结构或类的结构的默认继承是公共的。从另一个结构或类的结构的默认继承是私有的。
class A{    
public:    
    int i;      
};

class A2:A{    
};

struct A3:A{    
};


struct abc{    
    int i;
};

struct abc2:abc{    
};

class abc3:abc{
};


int _tmain(int argc, _TCHAR* argv[])
{    
    abc2 objabc;
    objabc.i = 10;

    A3 ob;
    ob.i = 10;

    //A2 obja; //privately inherited
    //obja.i = 10;

    //abc3 obss;
    //obss.i = 10;
}

这是在VS2005上。


_tmain不是标准的C ++。
melpomene

4

不在规格中,否。主要区别在于程序员在两年内阅读您的代码时的期望。结构通常被认为是POD。当您出于定义对象的目的而定义类型时,结构元数据也用于模板元编程中。


4

需要注意的另一件事是,如果更新了具有结构以使用类的旧版应用程序,则可能会遇到以下问题:

旧代码具有结构,代码已被清理,这些已更改为类。然后将一个或两个虚拟函数添加到新的更新类中。

当虚拟函数位于类中时,则在内部编译器将添加额外的指向类数据的指针以指向这些函数。

这将如何破坏旧的旧代码,如果在旧代码中某处使用memfill将结构清除为零,则这也会占用额外的指针数据。


1
使用memfill清除结构的代码可能还有其他令人反感的习惯。小心点。
David Thornley,2009年

@DavidThornley:使用零填充来擦除或初始化数据结构是C语言的标准。在混合语言项目中,不能指望C语言中的代码会避免calloc使用new。所有可以做的就是尝试确保代码的C部分使用的任何结构实际上都是PODS。
2013年

4
  1. 与关键字定义一个类的成员class都是private默认。默认情况下,使用关键字struct(或union)定义的类的成员public

  2. 在不存在访问说明符为基类的,public当假设派生类被声明structprivate所述类被声明当假定class

  3. 您可以声明一个,enum class但不能声明一个enum struct

  4. 您可以使用,template<class T>但不能使用template<struct T>

还要注意,C ++标准允许您将类型向前声明为struct,然后class在声明类型时使用,反之亦然。同样,std::is_class<Y>::valuetrue针对Y是a struct和a class,但是false针对a enum class


好的答案,虽然我错过了一个明确的明确0)structclassc ++之间的区别是关键字之间的区别,而不是数据类型之间的区别(或某些更好的替代方法;)
idclev 463035818

@ formerlyknownas_463035818:但是你不认为std::is_class<Y>::value涵盖了吗?
Bathsheba

是的,只是以为它可能会更加突出,因为那是常见的误解,而一旦这样,其余的只是推论。
idclev 463035818'19

没关系,您的答案是完美的,我写了另一个答案,
再也不怕

4

class和之间struct的区别是关键字之间的区别,而不是数据类型之间的区别。这两个

struct foo : foo_base { int x;};
class bar : bar_base { int x; };

两者都定义了一个类类型。在这种情况下,关键字的区别在于默认访问权限不同:

  • foo::x是公开的,并且foo_base是公开继承的
  • bar::x是私有的,并且bar_base是私有继承的


2

这只是一个约定。可以创建结构来保存简单数据,但是稍后会通过添加成员函数和构造函数来发展时间。另一方面,除了公开之外,看不到其他任何东西:结构中的访问。



2

另一个主要区别是在模板方面。据我所知,在定义模板时可以使用类,但不能使用结构。

template<class T> // OK
template<struct T> // ERROR, struct not allowed here

1
如果您打算强调结构不能用作通用类型,那么您错了。并且struct不允许仅按惯例使用(最好class在这里以不同的含义使用它的关键字,请参阅对模板参数使用'class'或'typename')。
dma_k 2011年

此处不允许使用关键字,但是您可以传入定义struct好的类。只需尝试一下。struct T{}; template <typename T> void foo() {} foo<T>();
轨道轻度竞赛

1

其他答案提到了私有/公共默认值(但请注意,结构是类是结构;它们不是两个不同的项目,而只是定义同一项目的两种方式)。

可能有趣的是要注意到的(特别是因为提问者可能会使用MSVC ++,因为他提到了“非托管的” C ++)是Visual C ++在某些情况下会抱怨是否先声明了类class,然后再定义了类struct(或者反之亦然)。 ),尽管该标准表示完全合法。


我知道这是一个很晚的评论,但是请注意,上述警告并非没有道理,因为Windows ABI操纵结构和类的方式有所不同,因此混合(转发)类和结构的声明实际上可能导致难以理解链接问题!
MFH

1
  • 。在类中,默认情况下所有成员都是私有的,而在结构中默认情况下所有成员都是公共的。

    1. 对于结构,没有像构造函数和析构函数这样的术语,但是对于类编译器,如果不提供,则会创建默认值。

    2. 空的Sizeof结构为0字节,而空的class为1字节结构默认访问类型为public。通常应将结构用于分组数据。

    类的默认访问类型为private,继承的默认模式为private。应该使用一个类对数据和对该数据进行操作的方法进行分组。

    简而言之,约定是在将数据分组时使用struct,而在我们需要数据抽象甚至继承的情况下使用类。

    在C ++中,除非明确取消引用,否则结构和类将按值传递。在其他语言中,类和结构可能具有不同的语义-即。对象(类的实例)可以通过引用传递,而结构可以通过值传递。注意:有与此问题相关的评论。请参阅讨论页添加到对话。


3
“ 2.由于Sizeof空类为1字节,因此sizeof空结构为0字节”。假。我刚测试过g++。您可能会想到“空基优化”,但这同样适用于两者。
cdunn2001

1
不对。在C ++中,空结构的大小为1。在C中,不允许空结构。GCC允许用C空结构作为一个编译器扩展和此类struct大小0
约翰RADE

这个答案是错误的。除了size之外,构造函数/析构函数部分也不准确:结构可以具有构造函数和析构函数就可以了。实际上,struct在C ++中创建了完整的类。
melpomene

1

尽管其他答案暗示了这一点,但并未明确提及-结构是C兼容的,具体取决于用法。类不是。

这意味着,如果您要编写要与C兼容的标头,则除了struct(C世界中没有函数;但可以具有函数指针)之外,您别无选择。


-1

您可以考虑使用此方法作为何时使用结构或类的准则,网址为https://msdn.microsoft.com/zh-cn/library/ms229017%28v=vs.110%29.aspx

√考虑如果类型的实例较小且通常为短寿命或通常嵌入在其他对象中,则定义结构而不是类。

X AVOID定义一个结构,除非该类型具有以下所有特征:

它在逻辑上表示一个值,类似于基本类型(int,double等)。

它的实例大小小于16个字节。

这是一成不变的。

不必经常装箱。


那是关于.NET / C#,而不是C ++。
melpomene

-2

类仅在软件工程的情况下才有意义。在数据结构和算法的上下文中,类和结构没有什么不同。没有任何规则限制必须引用该类的成员。

当开发大量的没有班级的大型项目时,您最终可能会得到复杂的耦合代码,因为每个人都可以使用他们想要的任何功能和数据。类提供权限控制和内在函数,以增强去耦和重用代码。

如果您阅读了一些软件工程原理,就会发现大多数标准如果没有上课就无法轻易实现。例如:http : //en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29

顺便说一句,当结构分配内存不足并包括多个变量时,值类型变量指示值嵌入在结构分配位置。相反,引用类型变量的值是外部的,并且是由指针引用的,该指针也嵌入在分配struct的位置。


这个答案似乎与C ++无关。在C ++中,struct声明类(包括权限控制,继承等)。
melpomene

-3

C ++中structclass关键字之间的区别在于,当在特定的复合数据类型上没有特定的说明符时,默认情况下structunion是仅考虑数据隐藏的public关键字,而class是考虑程序隐藏的private关键字。代码或数据。总是有些程序员为了代码而使用struct来存储数据和使用。有关更多信息,请联系其他来源。


OP已经提到struct默认情况下成员是公开的,2009年接受的答案提到了继承。为什么要写另一个答案,四年后再不添加新信息呢?
melpomene

-3

从所有这些因素中,可以得出结论,概念类非常适合表示现实世界的对象,而不是“结构”。很大程度上,因为类中使用的OOP概念在解释现实世界场景时非常实用,因此更容易将它们合并为现实。例如,默认继承是结构的公共属性,但是如果将此规则应用于现实世界,这是很荒谬的。但是在类中,默认继承是private,这是更现实的做法。

无论如何,我需要证明的是,类是一个更广泛的,在现实世界中适用的概念,而结构是一个内部组织较差的原始概念(Eventhough结构遵循OOP概念,它们的含义很差)。


1
私有继承如何“更现实”?大多数编程语言甚至都没有私有继承的概念。
melpomene

-3

oops中的structure和class关键字之间的主要区别在于,结构中不存在公共和私有成员声明。数据成员和成员函数可以定义为public,private和protected。


这个答案似乎与C ++无关。在C ++中,struct声明类(包括public/ private/ protected,继承等)。
melpomene

-3

**更新:**请忽略此回复。我没有考虑过该结构未初始化但只是碰巧为0的可能性。struct和class之间没有初始化差异。


我看到结构和类之间的另一个不同与默认初始化有关。

struct Foo {
    int a;
};

class Bar {
    int a;
};

class Tester {
    Foo m_Foo = Foo();
    Bar m_Bar = Bar();

public:
    Tester() {}
};

int main() {
    auto myTester = Tester();
}

运行该代码并检查myTester。您会发现,对于m_Foo,结构m_Foo.a已初始化为0,但是对于m_Bar,类m_Bar.a尚未初始化。因此,默认构造函数对struct vs.类的作用似乎有所不同。我在Visual Studio中看到了这一点。


1
您如何确定m_Foo.a已初始化?如果它尚未初始化而刚好是0怎么办?
melpomene

嗯,我没有。我的错。struct和class之间没有区别。初始化特性是相同的。
埃里克·希尔

-4

struct和class之间的主要区别在于,在struct中,您只能声明不同数据类型的数据变量,而在class中,您可以声明数据变量,成员函数,因此可以通过函数操作数据变量。

->我在类vs struct中发现的另一件方便的事情是,在程序中实现文件时,如果要对每个新的操作集一次又一次地执行struct的某些操作,则需要创建单独的函数,从文件中读取struct对象后传递它,以便对它进行一些操作。而在课堂上,如果您使函数每次都对所需的数据进行某些操作,那么只需从文件中读取对象并调用该函数即可。

但这取决于程序员他/她找到哪种方式...根据我的看法,我每次都更喜欢上课,只是因为它支持OOP,这就是它几乎以每种语言实现的原因,并且它是所有时间编程的奇妙功能;- )

是的,我忘了最难忘的区别是,类支持数据隐藏,并且还支持对内置数据类型执行的操作,而struct不支持!


1
在C ++中struct可以具有成员函数
chtz

@chtz谢谢...我现在才了解此功能..非常感谢..我只是一个初学者,不像您那么专家,所以将来还需要你们提供建议:-)
Yug Rawal

实际上,成员功能应具有更广泛的含义。struct可以具有构造函数,成员函数和析构函数(可能是虚拟的,可能是私有的,受保护的或公共的)。它们可以继承也可以被继承。所以实际上...一堂课可以拥有的一切。一个典型的约定是使用struct声明在C中将声明为struct的内容,如果我们声明私有和受保护的变量,虚函数,ctor和dtor等,则声明为类。但这只是约定,并非由语言强制执行
Gian Paolo

-5

我发现了另一个不同。如果您未在类中定义构造函数,则编译器将定义一个。但是在结构中,如果您未定义构造函数,则编译器也不会定义构造函数。因此在某些情况下我们确实不需要构造函数,因此struct是更好的选择(性能提示)。对不起,我的英语不好。


4
这不是真的。在这方面,structclass关键字定义的类和用关键字定义的类之间没有区别。
ymett 2011年

当我使用没有构造函数的结构时,我得到的速度要比没有构造函数的类快。
阿里

@Ali不,你不知道。
Lightness Races in Orbit,

-5

类是引用类型,结构是值类型。
当我说类是引用类型时,
基本上它们将包含实例变量的地址。

例如:

Class MyClass
{
    Public Int DataMember;  //By default, accessibility of class data members 
                            //will be private. So I am making it as Public which 
                            //can be accessed outside of the class.
}

在main方法中,
我可以使用new运算符创建此类的实例,该运算符为此类分配内存
并将其基址存储到MyClass类型变量(_myClassObject2)中。

Static Public void Main (string[] arg)
{
    MyClass _myClassObject1 = new MyClass();
    _myClassObject1.DataMember = 10;

    MyClass _myClassObject2 = _myClassObject1;
    _myClassObject2.DataMember=20;
}

在上面的程序中,MyClass _myClassObject2 = _myClassObject1; 指令指示两个MyClass类型的变量

  1. myClassObject1
  2. myClassObject2

并将指向相同的内存位置。
它基本上将相同的内存位置分配给另一个相同类型的变量。

因此,如果我们对任何一个MyType对象类型进行的更改都会对另一个对象产生影响,
因为这两个对象都指向相同的内存位置。

“ _myClassObject1.DataMember = 10;” 在此行,对象的两个数据成员都将包含值10。
“ _myClassObject2.DataMember = 20;” 在这一行,对象的数据成员都将包含值20。
最终,我们将通过指针访问对象的数据成员

与类不同,结构是值类型。例如:

Structure MyStructure
{
    Public Int DataMember;  //By default, accessibility of Structure data 
                            //members will be private. So I am making it as 
                            //Public which can be accessed out side of the structure.
}

Static Public void Main (string[] arg)
{
    MyStructure _myStructObject1 = new MyStructure();
    _myStructObject1.DataMember = 10;

    MyStructure _myStructObject2 = _myStructObject1;
    _myStructObject2.DataMember = 20;
}

在上述程序中,
使用新的运算符实例化MyStructure类型的对象,
并将地址存储到MyStructure类型的_myStructObject变量中,并
使用“ _myStructObject1.DataMember = 10”将值10分配给结构的数据成员。

在下一行中,
我声明了另一个MyStructure类型的变量_myStructObject2并将其分配给_myStructObject1。
.NET C#编译器在这里创建_myStructureObject1对象的另一个副本,
并将该内存位置分配给MyStructure变量_myStructObject2。

因此,无论我们对_myStructObject1进行的更改如何,都永远不会对MyStructrue类型的另一个变量_myStructObject2产生影响。
这就是为什么我们说结构是值类型。

因此,该类的直接基类是Object,而Structure的直接基类是ValueType,它从Object继承。
类将支持继承,而结构则不支持。

我们怎么说呢?
那是什么原因呢?
答案是班级。

它可以是抽象的,密封的,静态的和部分的,并且不能是私有的,受保护的和受保护的内部。


4
我认为这是试图回答C#的问题?问题是关于c ++的,这使答案不正确,对吗?
smw

@smw绝对是,他已经用C#编写了示例代码,我来这里是为了检查C ++ struct和之间传递的参数是否没有差异class。这里没有人提到它,也没有人提到整个网络。所以我也不认为这适用于C ++。
约翰

这甚至不是有效的C#代码-关键字都是错误的。“ Public”,“ Static”,“ Int”和“ Class”不应大写,而应“ struct”而非“ Structure”。描述对于C#来说大多是准确的(尽管结构仍然可以继承接口,但不能继承其他结构),但是由于它与C ++有关,所以无法回答问题……
Darrel Hoffman

2
这个答案完全是胡说八道。它在代码示例中使用了Visual Basic和C#的奇怪组合,并且整个“类是引用类型,结构是值类型” ...这仅适用于.NET(即C#),不适用于C ++。老兄,你在错误的房间里。这是您属于的地方:stackoverflow.com/questions/13049
TheFlash

但是这个答案表明对于C(++)同样有效,即像值类型一样使用结构。int a = 3; int b = a;类似的广告MyStruct a=MyStruct("data"); MyStruct b = a;
luckydonald

-8

结构和类别之间有3个基本区别

1St-Memory是为堆栈存储器中的结构保留的(接近于编程语言),是否为refrefence保留了堆栈存储器中的类,而堆内存中却保留了实际存储器。

2Nd-默认情况下,结构将类视为私有。

3Rd-不能在结构中重用代码,但在课堂上我们可以在很多时候重用相同的代码,称为固有


2
C ++结构确实支持继承和抽象方法。结构和类的分配方式相同。即使未使用“ new”实例化堆,也无法在堆上分配类对于嵌入式系统而言没有意义。
JCMS

2
#1也是错误的。当您将某种类型的内容声明为局部变量时,将使用堆栈,而当您使用“ new”运算符时,将使用堆。
Score_Under
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.