В чем разница между структурой и классом в C++?

Члены класса по умолчанию закрыты. Члены Struct по умолчанию являются общедоступными. Других отличий нет. Также см. этот вопрос.

Вот хорошее объяснение: http://carcino.gen.nz/tech/cpp/struct_vs_class.php

So, one more time: in C++, a struct is identical to a class except that the members of a struct have public visibility by default, but the members of a class have private visibility by default.

Нет в спецификации, нет. Основное различие заключается в ожиданиях программистов, когда они прочитают ваш код через 2 года. часто предполагается, что структуры являются POD. Структуры также используются в метапрограммировании шаблонов, когда вы определяете тип для целей, отличных от определения объектов.

Согласно Страуструпу в Язык программирования C++:

Which style you use depends on circumstances and taste. I usually prefer to use struct for classes that have all data public. I think of such classes as "not quite proper types, just data structures."

Функционально нет никакой разницы кроме публичного / приватного

Единственное другое отличие - это наследование классов и структур по умолчанию, которое, что неудивительно, является частным и открытым соответственно.

Это просто условность. Структуры могут быть созданы для хранения простых данных, но со временем они будут развиваться с добавлением функций-членов и конструкторов. С другой стороны, необычно видеть что-либо кроме public: access в структуре.

Цитата C++ FAQ,

[7.8] What's the difference between the keywords struct and class?

The members and base classes of a struct are public by default, while in class, they default to private. Note: you should make your base classes explicitly public, private, or protected, rather than relying on the defaults.

Struct and class are otherwise functionally equivalent.

OK, enough of that squeaky clean techno talk. Emotionally, most developers make a strong distinction between a class and a struct. A struct simply feels like an open pile of bits with very little in the way of encapsulation or functionality. A class feels like a living and responsible member of society with intelligent services, a strong encapsulation barrier, and a well defined interface. Since that's the connotation most people already have, you should probably use the struct keyword if you have a class that has very few methods and has public data (such things do exist in well designed systems!), but otherwise you should probably use the class keyword.

STRUCT - это тип абстрактного типа данных, который разделяет заданный фрагмент памяти в соответствии со спецификацией структуры. Структуры особенно полезны при сериализации / десериализации файлов, поскольку структура часто может быть записана в файл дословно. (т.е. получить указатель на структуру, использовать макрос SIZE для вычисления количества байтов для копирования, а затем переместить данные в структуру или из нее.)

Классы - это другой тип абстрактного типа данных, который пытается обеспечить скрытие информации. Внутри может быть множество махинаций, методов, временных переменных, переменных состояния. и т.д., которые все используются для представления согласованного API для любого кода, который хочет использовать класс.

Фактически, структуры относятся к данным, классы - к коду.

Однако вам нужно понимать, что это просто абстракции. Вполне возможно создавать структуры, которые очень похожи на классы, и классы, которые очень похожи на структуры. Фактически, самые ранние компиляторы C++ были просто предварительными компиляторами, которые переводили код C++ в C. Таким образом, эти абстракции являются преимуществом для логического мышления, а не обязательно активом для самого компьютера.

Помимо того, что каждый из них представляет собой отдельный тип абстракции, классы предоставляют решения для загадки именования кода C. Поскольку у вас не может быть более одной функции с одним и тем же именем, разработчики использовали шаблон _ (). например mathlibextreme_max (). Группируя API в классы, аналогичные функции (здесь мы называем их «методами») можно сгруппировать вместе и защитить от именования методов в других классах. Это позволяет программисту лучше организовать свой код и увеличить повторное использование кода. По крайней мере, теоретически.

Еще одно замечание: если вы обновили устаревшее приложение, в котором были структуры для использования классов, вы можете столкнуться со следующей проблемой:

В старом коде есть структуры, код был очищен и заменен на классы. Затем к новому обновленному классу были добавлены одна или две виртуальные функции.

Когда виртуальные функции находятся в классах, внутри компилятор добавит дополнительный указатель на данные класса, чтобы указать на функции.

Если бы в старом коде где-то структура была очищена с помощью memfill, чтобы очистить все до нулей, это могло бы сломать старый унаследованный код, это также уничтожило бы дополнительные данные указателя.

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.

Вы забываете о сложной второй разнице между классами и структурами.

Произнесите стандарт (§11.2.2 в C++ 98 - C++ 11):

In absence of an access-specifier for a base class, public is assumed when the derived class is declared struct and private is assumed when the class is declared class.

И просто для полноты картины более широко известное различие между классом и структурой определено в (11.2):

Member of a class defined with the keyword class are private by default. Members of a class defined with the keywords struct or union are public by default.

Дополнительное отличие: ключевое слово class можно использовать для объявления параметров шаблона, а ключевое слово struct нельзя.

ISO IEC 14882-2003

9 Classes

§3

A structure is a class defined with the class-keystruct; its members and base classes (clause 10) are public by default (clause 11).

Стоит помнить о происхождении C++ и его совместимости с C.

В C есть структуры, в нем нет концепции инкапсуляции, поэтому все является общедоступным.

Общедоступность по умолчанию обычно считается плохой идеей при использовании объектно-ориентированного подхода, поэтому при создании формы C, которая изначально способствовала бы ООП (вы можете выполнять ОО на C, но это вам не поможет), что было Идея в C++ (первоначально «C с классами») имеет смысл сделать члены закрытыми по умолчанию.

С другой стороны, если бы Страуструп изменил семантику struct так, чтобы его члены были закрытыми по умолчанию, это нарушило бы совместимость (это уже не так часто, как расходятся стандарты, но все допустимые программы на C также были действительными программами на C++. , что оказало большое влияние на закрепление C++).

Таким образом, было введено новое ключевое слово class, которое в точности похоже на структуру, но по умолчанию является закрытым.

Если бы C++ появился с нуля, без истории, то, вероятно, у него было бы только одно такое ключевое слово. Это также, вероятно, не повлияло бы на то, что произвело.

В общем, люди будут склонны использовать структуры, когда они делают что-то вроде того, как структуры используются в C; общедоступные члены, без конструктора (пока он не в объединении, у вас может есть конструкторы в структурах, как и в случае с классами, но люди, как правило, не имеют), без виртуальных методов и т.д. люди, читающие код, чтобы проинструктировать машины (иначе мы бы придерживались ассемблерных и необработанных кодов операций виртуальной машины), это хорошая идея.

Я нашел другое отличие. если вы не определяете конструктор в классе, компилятор определит его. но в структуре, если вы не определяете конструктор, компилятор также не определяет конструктор. поэтому в некоторых случаях, когда нам действительно не нужен конструктор, лучше выбрать struct (совет по производительности). и извините за мой плохой английский.

В других ответах упоминались частные / общедоступные значения по умолчанию (но обратите внимание, что структура - это класс, это структура; это не два разных элемента, а всего два способа определения одного и того же элемента).

Что может быть интересно отметить (особенно потому, что запрашивающий, вероятно, использует MSVC++, поскольку он упоминает «неуправляемый» C++), так это то, что Visual C++ при определенных обстоятельствах жалуется, если класс объявлен с помощью class, а затем определен с помощью struct (или, возможно, другого наоборот), хотя в стандарте сказано, что это совершенно законно.

Еще одно важное отличие - это шаблоны. Насколько мне известно, вы можете использовать класс, когда определяете шаблон, но НЕ структуру.

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

• . В классах все члены по умолчанию частные, но по структуре участники по умолчанию являются общедоступными.

  1. Для структур нет таких терминов, как конструктор и деструктор, но для классов компилятор создает значения по умолчанию, если вы не предоставляете их.

  2. Размер пустой структуры равен 0 байтам, а размер пустого класса Sizeof равен 1 байту. Тип доступа к структуре по умолчанию - открытый. Структура должна обычно используется для группировки данных.

  Тип доступа по умолчанию для класса - частный, а режим по умолчанию для наследование частное. Класс следует использовать для группировки данных и методы, которые работают с этими данными.

  Короче говоря, соглашение заключается в использовании структуры, когда цель состоит в том, чтобы группировать данные и использовать классы, когда нам требуется абстракция данных и, возможно наследование.

  В C++ структуры и классы передаются по значению, если явно не ссылка на которую отменена. В других языках классы и структуры могут иметь отличная семантика - т.е. объекты (экземпляры классов) могут быть переданы по ссылке, а структуры могут передаваться по значению. Примечание: есть комментарии, связанные с этим вопросом. См. Страницу обсуждения, чтобы добавить в беседу.

Разница между ключевыми словами структура и учебный класс в C++ заключается в том, что, когда нет конкретного спецификатора для определенного составного типа данных, тогда по умолчанию структура или союз являются общедоступными ключевыми словами, которые просто рассматривают скрытие данных, но класс - это частное ключевое слово, которое рассматривает скрытие программы. коды или данные. Некоторые программисты всегда используют структура для данных и учебный класс для кода. За дополнительной информацией обращайтесь в другие источники.

Исходя из всех этих факторов, можно сделать вывод, что концепция Class очень подходит для представления объектов реального мира, а не «структур». Во многом потому, что концепции ООП, используемые в классе, очень практичны при объяснении сценариев реального мира, поэтому их легче объединить с реальностью. Например, наследование по умолчанию для структур является общедоступным, но если мы применим это правило в реальном мире, это будет смешно. Но в классе по умолчанию наследование является частным, что более реалистично.

В любом случае, что мне нужно обосновать, так это то, что класс - это гораздо более широкая, применимая в реальном мире концепция, тогда как структура - это примитивная концепция с плохой внутренней организацией (структура Eventhough следует концепциям ООП, они имеют плохое значение)

Классы являются ссылочными типами, а структуры - типами значений. Когда я говорю, что классы являются ссылочными типами,
в основном они будут содержать адрес переменных экземпляра.

Например:

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.
}

В основном методе
Я могу создать экземпляр этого класса, используя новый оператор, который выделяет память для этого класса
и сохраняет его базовый адрес в переменной типа 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

и будет указывать на то же место в памяти. По сути, он назначает ту же ячейку памяти другой переменной того же типа.

Поэтому, если какие-либо изменения, которые мы вносим в один из объектов типа MyClass, повлияют на другой объект
поскольку оба указывают на одно и то же место в памяти.

"_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 с использованием оператора new и
сохранение адреса в переменной _myStructObject типа MyStructure и
присвоение значения 10 элементу данных структуры с помощью «_myStructObject1.DataMember = 10».

В следующей строке
Я объявляю другую переменную _myStructObject2 типа MyStructure и назначаю ей _myStructObject1.
Здесь компилятор .NET C# создает еще одну копию объекта _myStructureObject1 и
назначает эту ячейку памяти переменной MyStructure _myStructObject2.

Поэтому любое изменение, которое мы вносим в _myStructObject1, никогда не повлияет на другую переменную _myStructObject2 типа MyStructrue.
Вот почему мы говорим, что структуры - это типы значений.

Таким образом, непосредственным базовым классом для класса является Object, а непосредственным базовым классом для структуры является ValueType, который наследуется от Object.
. Классы будут поддерживать наследование, а структуры - нет.

Как мы это говорим?
И в чем причина этого?
Ответ - классы.

Он может быть абстрактным, запечатанным, статическим и частичным и не может быть частным, защищенным или защищенным внутренним.

Основное различие между ключевым словом структуры и класса в oops заключается в том, что в структуре отсутствуют публичные и частные объявления членов. А член данных и функция-член могут быть определены как публичные, частные, а также защищенные.

Есть 3 основных различия между структурой и классом

1St-память зарезервирована для структуры в стековой памяти (что близко к языку программирования), зарезервированы ли для класса в стековой памяти только для справки, а фактическая память зарезервирована в динамической памяти.

2Nd - По умолчанию структура обрабатывается как общедоступная, независимо от того, рассматривается ли класс как частный.

3Rd - нельзя повторно использовать код в структуре, но в классе мы можем повторно использовать один и тот же код много раз, что называется наследованием.

Класс имеет значение только в контексте разработки программного обеспечения. В контексте структур данных и алгоритмов класс и структура не сильно отличаются. Нет никакого правила, ограничивающего указание на член класса.

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

Если вы прочитаете некоторые принципы разработки программного обеспечения, вы обнаружите, что большинство стандартов не могут быть легко реализованы без классов. Например: http://en.wikipedia.org/wiki/SOLID_%28object-oriated_design%29

Кстати, когда структура выделяет небольшой объем памяти и включает в себя несколько переменных, переменные типа значения указывают, что значения встроены в то место, где выделяется структура. Напротив, значения переменных ссылочного типа являются внешними и ссылаются на указатель, который также встроен в место, где размещается структура.

Вы можете рассмотреть это как рекомендации о том, когда использовать структуру или класс, https://msdn.microsoft.com/en-us/library/ms229017%28v=vs.110%29.aspx.

√ CONSIDER defining a struct instead of a class if instances of the type are small and commonly short-lived or are commonly embedded in other objects.

X AVOID defining a struct unless the type has all of the following characteristics:

It logically represents a single value, similar to primitive types (int, double, etc.).

It has an instance size under 16 bytes.

It is immutable.

It will not have to be boxed frequently.

** ОБНОВЛЕНИЕ: ** Не обращайте внимания на этот ответ. Я не рассматривал возможность того, что для структуры значение было неинициализированным, а просто оказалось равным 0. Разницы в инициализации между структурой и классом нет.

Я вижу еще одно различие между структурами и классами, связанное с инициализацией по умолчанию.

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 не инициализирован. Таким образом, похоже, есть разница в том, что конструктор по умолчанию делает для структуры и класса. Я вижу это в Visual Studio.

1) Члены класса по умолчанию являются закрытыми, а члены структуры по умолчанию являются общедоступными.

Например, программа 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;
}

Хотя это подразумевается другими ответами, это явно не упоминается - что структуры совместимы с C, в зависимости от использования; классов нет.

Это означает, что если вы пишете заголовок, который вы хотите быть совместимым с C, тогда у вас нет другого выбора, кроме struct (который в мире C не может иметь функций; но может иметь указатели на функции).

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

-> Еще одна удобная вещь, которую я нахожу в классе vs struct, заключается в том, что при реализации файлов в программе, если вы хотите снова и снова выполнять некоторые операции структуры при каждом новом наборе операций, вам нужно сделать отдельную функцию, и вам нужно передать объект структуры после чтения его из файла, чтобы выполнить с ним некоторые операции. находясь в классе, если вы создаете функцию, которая выполняет некоторые операции с данными, которые необходимы каждый раз ... это просто, вам просто нужно прочитать объект из файла и вызвать функцию ..

Но это зависит от программиста, какой способ он / она сочтет подходящим ... по моему мнению, я предпочитаю класс каждый раз только потому, что он поддерживает ООП, и именно по этой причине он реализован почти на всех языках, и это замечательная особенность программирования на все времена; - )

И да, самая незабываемая разница, о которой я забыл упомянуть, заключается в том, что класс поддерживает скрытие данных, а также поддерживает операции, которые выполняются со встроенными типами данных, в то время как struct не поддерживает!

1. Членами класса, определенного ключевым словом class, по умолчанию являются private. Члены класса, определенного ключевыми словами struct (или union), по умолчанию являются public.

2. При отсутствии спецификатора доступа для базового класса предполагается, что public, когда класс полученный объявлен как struct, и private предполагается, когда класс объявлен как class.

3. Вы можете объявить enum class, но не enum struct.

4. Вы можете использовать template<class T>, но не template<struct T>.

Также обратите внимание, что стандарт C++ позволяет вам напрямую объявлять тип как struct, а затем использовать class при объявлении типа и наоборот. Кроме того, std::is_class<Y>::value является true для Y, являющегося struct и class, но является false для enum class.

Разница между class и struct - это разница между ключевыми словами, а не между типами данных. Эти два

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

оба определяют тип класса. Разница ключевых слов в этом контексте заключается в разном доступе по умолчанию:

• foo::x является публичным, а foo_base унаследован публично.
• bar::x является частным, а bar_base наследуется частным образом.