Частни членове на структура в C с const

Това нарушава C 2011 6.2.7 1.

6.2.7 1 изисква две дефиниции на една и съща структура в различни единици за превод да имат съвместим тип. Не е разрешено да има const в едното, а не в другото.

В един модул може да имате препратка към един от тези обекти и членовете изглеждат const за компилатора. Когато компилаторът записва извиквания към функции в други модули, той може да съдържа стойности от константните членове в регистри или друг кеш или в частично или напълно оценени изрази от по-късен етап в изходния код от извикването на функцията. Тогава, когато функцията модифицира члена и се върне, оригиналният модул няма да има променената стойност. Още по-лошо, може да използва някаква комбинация от променената и старата стойност.

Това е изключително неправилно програмиране.

Това почти сигурно е недефинирано поведение.

Писането/модифицирането на обект, деклариран като const, е забранено и това води до UB. Освен това подходът, който предприемате, повторно декларира struct 2DPoint като два технически различни типа, което също не е разрешено.

Обърнете внимание, че това (като недефинирано поведение като цяло) не означава, че "със сигурност няма да работи" или "трябва да се срине". Всъщност намирам за съвсем логично, че работи, защото ако човек чете интелигентно източника, лесно може да разбере каква е целта му и защо може да се счита за правилен. Компилаторът обаче не е интелигентен - в най-добрия случай това е краен автомат, който няма познания какво трябва да прави кодът; то само се подчинява (повече или по-малко) на синтактичните и семантичните правила на граматиката.

По думите на Bjarne Stroustrup: C не е проектиран да поддържа ООП, въпреки че разрешава ООП, което означава, че е възможно да се пишат ООП програми на C, но е много трудно да се направи така. Като такъв, ако трябва да напишете ООП код на C, изглежда няма нищо лошо в използването на този подход, но е за предпочитане да използвате език, който е по-подходящ за целта.

Опитвайки се да напишете ООП код на C, вие вече сте навлезли в територия, където „здравият разум“ трябва да бъде пренебрегнат, така че този подход е добър, стига да поемете отговорност да го използвате правилно. Също така трябва да се уверите, че той е задълбочено и стриктно документиран и че всеки, който има отношение към кода, е наясно с него.

Редактиране О, може да се наложи да използвате гипс, за да заобиколите const. Не успявам да си спомня дали кастингът в стил C може да се използва като C++ const_cast.

Можете да използвате различен подход - декларирайте два structs, един за потребител без частни членове (в заглавката) и един с частни членове за вътрешна употреба във вашия модул за изпълнение. Всички частни членове трябва да бъдат поставени след публичните.

Винаги заобикаляте указателя към struct и го прехвърляте за вътрешна употреба, когато е необходимо, по следния начин:

/* user code */
struct foo {
    int public;
};

int bar(void) {
    struct foo *foo = new_foo();
    foo->public = 10;
}

/* implementation */
struct foo_internal {
    int public;
    int private;
};

struct foo *new_foo(void) {
    struct foo_internal *foo == malloc(sizeof(*foo));
    foo->public = 1;
    foo->private = 2;
    return (struct foo*)foo;  // to suppress warning
}

C11 позволява неименувани структурни полета (GCC го поддържа известно време), така че в в случай на използване на GCC (или C11 съвместим компилатор), можете да декларирате вътрешна структура като:

struct foo_internal {
    struct foo;
    int private;
};

следователно не са необходими допълнителни усилия за поддържане на дефинициите на структурата в синхрон.