struct A
{
private:
    int _val;

public:
    int getVal() { return _val; }

    void setVal(int val)
    {
        if (val < 0)
            throw "требования инкапсуляции не допускают установку "
                "отрицальтного значения свойству Val.";
                
        _val = val;
    }
};

void main()
{
    A a;
    a.setVal(123);  // OK
    a.setVal(-123); // Облом в рантайме.
    a._val = -123;  // Облом во время компиляции.
}

struct A
{
    int _val;
};

void mian()
{
    A a;
    a._val = -123;  // Нарушение принципов инкапсуляции. Подразумевается что A::_val не может содержать отрицальное значение.
}

struct A; // A объявлено, но не определено
int getVal(struct A const*);
void setVal(struct A*, int);

F>struct A; // A объявлено, но не определено
F>int getVal(struct A const*);
F>void setVal(struct A*, int);
F>

более совершенные с точки зрения инкапсуляции языки вроде С++, Явы, Шарпа...

> Она в нем есть.

> struct A
> {
> private:
>     int _val;
>
> public:
>     int getVal() { return _val; }
>
>     void setVal(int val)
>     {
>         if (val < 0)
>             throw "требования инкапсуляции не допускают установку "
>                 "отрицальтного значения свойству Val.";
>        _val = val;
>     }
> };
>
> void main()
> {
>     A a;
>     a.setVal(123);  // OK
>     a.setVal(-123); // Облом в рантайме.
>     a._val = -123;  // Облом во время компиляции.
> }

typedef int ErrorCode;

#define A_OK                 ((ErrorCode)0)

// Требования инкапсуляции не допускают установку
// отрицальтного значения свойству Val.
//
#define A_ERROR_INVALID_VAL  ((ErrorCode)-1)

typedef struct Atag A;

A*        create_A(void);
void      delete_A(A*);
int       A_getVal(A*);
ErrorCode A_setVal(A*, int);

. . .

struct Atag
{
   int _val;
};

A* create_A(void)
{
   A* a = (A*)malloc(sizeof(A));
   return a;
}

void delete_A(A* a)
{
   free(a);
}

int A_getVal(A* a)
{
   return a->_val;
}

ErrorCode setVal(A* a, int val)
{
   if (val < 0)
     return A_ERROR_INVALID_VAL;

   a->_val = val;
   return A_OK;
}

int main()
{
   A*        a;
   ErrorCode err_code;

   a = create_A();
   if (!a)
     return -1;

   err_code = 0;

   . . .

   if (err_code != A_OK)
     err_code = A_setVal(a, 123);  // OK

   if (err_code != A_OK)
     err_code = A_setVal(a, -123); // Облом в рантайме.

   if (err_code != A_OK)
     a->_val = -123;  // Облом во время компиляции.

   delete_A(a);

   return err_code == A_OK ? 0 : -1;
}

Да сишники вот уже 35 лет слона не замечают. Хотя не все. Многие просто чисто интиуитивно переползают на более совершенные с точки зрения инкапсуляции языки вроде С++, Явы, Шарпа...

С++, Явы, Шарпа обладают более совершенными средствами инкапсуляции.

ПК> Интересно... А в чем, по-твоему, большее совершенство, скажем, C++ по сравнению c С с точки зрения инкапсуляции?

Она в нем есть.

class Ultimate
{
   struct Ultimate_imp   *imp_;
public:
   void foo();
   void bar();
};

class Foo
{
   void everything_get( const char *name, void *out );
public:
   int foo_get() { int x; everything_get("foo",&x); return x; }
};

ПК>Наверное, мы просто стали чаще бывать в одних и тех же форумах

Я с тобой согласен в отношении того, что в C++ легче сокрыть данные, чем в C.

Отчего же, он вполне хорошо проиллюстрировал твою позицию, здорово сэкономив нам время на ненужной риторике. Как видишь, C вполне позволяет писать код, эквивалентный в отношении инкапсуляции коду на C++. Скажем, та же Win API в этом отношении вполне в порядке.

Многие просто чисто интиуитивно переползают на более совершенные с точки зрения инкапсуляции языки вроде С++, Явы, Шарпа...

Многие просто чисто интиуитивно переползают на более совершенные с точки зрения инкапсуляции языки вроде С++, Явы, Шарпа...

// класс A поддерживает (реализует) абстракцию - тип с функциями-членами foo() и bar() - но при этом не закрывает _data_member
class Ab
{
 public:
  void foo();
  void bar();
  int _data_member;
};

// класс B поддерживает (реализует) ту же абстракцию, но _data_member закрыт - вот она, инкапсуляция
class B
{
 public:
  void foo();
  void bar();
 private:
  int _data_member;
};

In computer science, information hiding is leaving out some details of implementation on purpose from the public. Encapsulation is, besides hiding, to provide common interfaces.

Forbidden
You don't have permission to access /index.pl on this server.
--------------------------------------------------------------------------------
Apache/2.0.46 (Red Hat) Server at www.livejornal.com Port 80

F>>// класс A поддерживает (реализует) абстракцию - тип с функциями-членами foo() и bar()
F>>// - но при этом не закрывает _data_member
F>>class Ab
F>>{
F>> public:
F>>  void foo();
F>>  void bar();
F>>  int _data_member;
F>>};

struct { void foo(); void bar(); };

G>Возможно. Меня как инженера не интересует information hiding. Это не привносит ничего интересного в процесс разработки и дизайна, если думаешь в терминах ADT. Тем более, не вижу смысла в маниакальном сокрытии данных в рамках одного проекта — люди и так узнают внутренности, если захотят — им достаточно просто спросить об этом автора . А если им не понятно, что такое public interface, то вопрос решается не техническими средствами, а простым обучением (хотя таких лучше на работу не брать).

struct { void foo(); void bar(); };

class SomeClassA : public InterfaceA, public InterfaceB
{
};

SomeClassA obj;

void foo1(const SomeClassA&);
void foo2(const InterfaceA&);
void foo3(const InterfaceB&);

foo1(obj); // ОК
foo2(obj); // ОК
foo3(obj); // ОК

struct { void foo(); void bar(); };

int main()
{
  A a;
  a.foo(5);
  return a.bar();
}

struct A { void foo(int); int bar(); };

struct A
{
  A(): _data(1) {}  

  void foo(int x) { _set_data( x ? x : 1 ); }
  int bar() const { return 1000 / x; }
  
  void _set_data(int x) { _data = x; }
  int _data;
};

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

> Он может вам не сказать , а вы не сможете посмотреть.

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

struct { void foo(); void bar(); };

F>int main()
F>{
F>  A a;
F>  a.foo(5);
F>  return a.bar();
F>}
F>

struct A { void foo(int); int bar(); };

F>struct A
F>{
F>  A(): _data(1) {}  

F>  void foo(int x) { _set_data( x ? x : 1 ); }
F>  int bar() const { return 1000 / x; }
  
F>  void _set_data(int x) { _data = x; }
F>  int _data;
F>};
F>

Что и имеет место быть в случае, когда вы покупаете готовый ActiveX компонент, например (вот случай, когда надо необходимо скрыть реализацию).