Чому я можу визначити структури та класи всередині функції в C ++?

Я просто помилково зробив щось подібне в C ++, і це працює. Чому я можу це зробити?

int main(int argc, char** argv) {
    struct MyStruct
    {
      int somevalue;
    };

    MyStruct s;
    s.somevalue = 5;
}

Тепер, зробивши це, я якось згадав, як колись давно читав про цей трюк як свого роду інструмент функціонального програмування бідної людини на C ++, але я не можу згадати, чому це дійсно, або де я його читав.

Відповіді на будь-яке питання вітаються!

Примітка: Хоча під час написання запитання я не отримав жодного посилання на це питання , поточна бічна панель вказує на нього, тому я поміщу його тут для довідки, в будь-якому випадку питання інше, але може бути корисним.

[EDIT 18/4/2013]: На щастя, згадане нижче обмеження було скасовано в C ++ 11, тому локально визначені класи все-таки корисні! Завдяки коментатору бамбуку.

Можливість локального визначення класів зробила б створення користувальницьких функторів (класів з operator()(), наприклад, функціями порівняння для передачі std::sort()або "тіл циклу", які будуть використовуватися std::for_each()) набагато зручнішими.

На жаль, C ++ забороняє використовувати локально визначені класи з шаблонами , оскільки вони не мають зв’язку. Оскільки більшість програм функторів включають типи шаблонів, які шаблоновані за типом функтора, локально визначені класи для цього використовувати не можна - їх потрібно визначити поза функцією. :(

[РЕДАКТУВАТИ 1/11/2009]

Відповідна цитата зі стандарту:

14.3.1 / 2: .Локальний тип, тип без зв’язку, неназваний тип або тип, складений із будь-якого з цих типів, не повинні використовуватися як аргумент шаблону для параметра типу шаблону.

Одне з застосувань локально визначених класів C ++ - це шаблон фабричного проектування :

// In some header
class Base
{
public:
    virtual ~Base() {}
    virtual void DoStuff() = 0;
};

Base* CreateBase( const Param& );

// in some .cpp file
Base* CreateBase( const Params& p )
{
    struct Impl: Base
    {
        virtual void DoStuff() { ... }
    };

    ...
    return new Impl;
}

Хоча ви можете зробити те саме з анонімним простором імен.

Насправді це дуже корисно для виконання деяких робіт із забезпечення безпеки на основі стеків. Або загальне очищення від функції з кількома точками повернення. Це часто називають ідіомою RAII (залучення ресурсів - це ініціалізація).

void function()
{

    struct Cleaner
    {
        Cleaner()
        {
            // do some initialization code in here
            // maybe start some transaction, or acquire a mutex or something
        }

        ~Cleaner()
        {
             // do the associated cleanup
             // (commit your transaction, release your mutex, etc.)
        }
    };

    Cleaner cleaner;

    // Now do something really dangerous
    // But you know that even in the case of an uncaught exception, 
    // ~Cleaner will be called.

    // Or alternatively, write some ill-advised code with multiple return points here.
    // No matter where you return from the function ~Cleaner will be called.
}

Ну, в основному, чому б і ні? A structв С (повернення до зорі часу) було лише способом оголосити структуру записів. Якщо ви його хочете, чому б не змогти оголосити його там, де ви оголосите просту змінну?

Зробивши це, тоді пам’ятайте, що метою С ++ було бути сумісним із С, якщо це можливо. Так воно і залишилось.

Це згадується, наприклад, у розділі "7.8: Локальні класи: класи всередині функцій" http://www.icce.rug.nl/documents/cplusplus/cplusplus07.html, який називає його "локальним класом" і каже " може бути дуже корисним у розширених додатках, що включають успадкування або шаблони ".

Він призначений для створення масивів об’єктів, які правильно ініціалізовані.

У мене є клас C, який не має конструктора за замовчуванням. Я хочу масив об'єктів класу C. Я з'ясовую, як я хочу, щоб ці об'єкти ініціалізувались, а потім вивів клас D із C за допомогою статичного методу, який забезпечує аргумент для C у конструкторі D за замовчуванням:

#include <iostream>
using namespace std;

class C {
public:
  C(int x) : mData(x)  {}
  int method() { return mData; }
  // ...
private:
  int mData;
};

void f() {

  // Here I am in f.  I need an array of 50 C objects starting with C(22)

  class D : public C {
  public:
    D() : C(D::clicker()) {}
  private:
    // I want my C objects to be initialized with consecutive
    // integers, starting at 22.
    static int clicker() { 
      static int current = 22;
      return current++;
    } 
  };

  D array[50] ;

  // Now I will display the object in position 11 to verify it got initialized
  // with the right value.  

  cout << "This should be 33: --> " << array[11].method() << endl;

  cout << "sizodf(C): " << sizeof(C) << endl;
  cout << "sizeof(D): " << sizeof(D) << endl;

  return;

}

int main(int, char **) {
  f();
  return 0;
}

Для простоти в цьому прикладі використовується тривіальний конструктор, який не використовується за замовчуванням, і випадок, коли значення відомі під час компіляції. Це просто поширити цю техніку на випадки, коли вам потрібен масив об’єктів, ініціалізований значеннями, які відомі лише під час виконання.