Можно написать прогу по-другому?

[Event]

Когда в С++ создаешь массив n обьектов, то конструктор вызывается n
раз автоматически. Как инициализировать каждый обьект в отдельности?
Или, например, в цикле?

[zss]

Чтобы конструктор не вызывался автоматически нужно добавить
перед ним префикс explicit.
Такие конструкторы будут вызываться только в явных случаях типа
MyClass c1(10,1.5);

[kvm]

Конструктор у объектов С++ вызывается всегда, даже если программист не объявлял его, компилятор сам добавит конструктор по-умолчанию и таки вызовет его
Для инициализации каждого объекта в отдельности, нужно просто объявить пустой конструктор, а всю инициализацию производить в отдельной функции, например init(), start() или что-то в этом роде. Таким образом, можно будет пробежаться в цикле по массиву и вызвать для каждого объекта инициализирующую функцию тогда, когда это будет необходимо.

Пример:

class A
{
public:
	A() {} //Пустой конструктор
	~A();
        void init(); //Здесь производим инициализацию
};

int main( int argc, char* argv[] )
{
	const size_t array_size = 10;
	A a[ array_size ];
	for( size_t i = 0; i < array_size; ++i )
	{
		a.init();
	}
	return 0;
}

[zss]

Цитата: Сообщение от kvm Конструктор у объектов С++ вызывается всегда, даже если программист не объявлял его, компилятор сам добавит конструктор по-умолчанию и таки вызовет его

Да, если не объявлял, то создается конструктор по умолчанию, но если объявить конструктор без параметров с префиксом explicit, то он будет использоваться только при явном вызове.

[kvm]

Цитата: Сообщение от zss Да, если не объявлял, то создается конструктор по умолчанию, но если объявить конструктор без параметров с префиксом explicit, то он будет использоваться только при явном вызове.

Конструктор в C++ вызывается всегда. Рекомендую откомпилировать этот листинг и посмотреть, что получится:

#include "stdafx.h"
#include <iostream>

class A
{
public:
	explicit A()
	{
		std::cout << "Constructor A" << std::endl;
	}
	~A()
	{
		std::cout << "Destructor A" << std::endl;
	}
};

int main( int argc, char* argv[] )
{
	const size_t array_size = 10;
	A a[ array_size ];
	return 0;
}

Чтобы не быть совсем уж голословным, приведу цитату из стандарта: статья 12, часть 6, пункт 3 — Инициализация.

Цитата: 12.6.3 Initialization When an array of class objects is initialized (either explicitly or implicitly), the constructor shall be called for each element of the array, following the subscript order; see 8.3.4. [ Note: destructors for the array elements are called in reverse order of their construction. — end note ]

[zss]

Да, действительно я опростоволосился...
Конструктор без параметров не бывает неявным.
Вопрос тогда вопрос, какая польза от explicit.
Я один пример придумал:

class C
{
    int i;
public:
	C(){i=0;}
    explicit C(const C &a){i=a.i;} 
	void set(int n){i=n;}
	C& operator=(const C &a){i=a.i;return *this;}
};

int main()
{
        C c;c.set(1);
	C e(c); // правильно, явно вызван копиконструктор
 //     C d=c;// ошибка (при инициализации используется копи конструктор)
	C d;d=c; // правильно(через operator=)
}

[kvm]

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

Наиболее наглядный пример использования explicit (лично для меня) выглядит так:

#include <iostream>

class String
{
public:
	String() : size_( 0 ), str_( NULL )
	{
	}
	~String()
	{
		if ( NULL != str_ )
		{
			delete [] str_;
		}
	}
	String( size_t size )
	{
		size_ = size;
		str_ = new char[ size ];
		memset( str_, 0, size_ );
	}
private:
	size_t size_;
	char* str_;
};

int main( int argc, char* argv[] )
{
	String a = 10;
	return 0;
}

Допустим, мы используем сторонний класс реализующий строку. В приведенном примере, прикладной программист ожидает, что:

std::cout << a << std::endl;

выведет 10 в стандартный поток вывода, т.е. a = "10". Однако, это не так.

Чтобы избежать такой ситуации конструктор String( size_t size ) следует объявить explicit, тогда компилятор выдаст ошибку и программисту придётся обратиться к определению класса и разобраться в чём дело.


Ваш пример на практике используется для запрещения возвращать объект класса из функции по значению.

Допустим, Ваш класс попал к другому программисту и он решил расширить его функционал, добавив функцию сравнения следующим образом:

class C
{
	int i;
public:
	C(){i=0;}
	C(const C &a){i=a.i;} 
	void set(int n){i=n;}
	C& operator=(const C &a){i=a.i;return *this;}
	friend C cmp( const C& a, const C& b )
	{
		C c;
                c = b;
		if ( a.i >= b.i )
		{
			c = a;
		}
		return c;
	}
};

Зачем-то он создал лишний временный объект, наверное, лабораторные в своё время сдавал с помощью этого или подобного сайта

Так вот объявление конструктора копирования explicit заставит его немного подумать, так как компилятор выдаст ошибку. И код превратится в нечто такое:

friend const C& cmp( const C& a, const C& b )
	{
		if ( a.i >= b.i )
		{
			return a;
		}
		return b;
	}

Вот пример из моего реального проекта:

class auto_file_handle
{
public:
	explicit auto_file_handle( HANDLE handle) : handle_( handle ) {}
	~auto_file_handle() 
	{
		if ( INVALID_HANDLE_VALUE != handle_ ) 
		{
			::CloseHandle( handle_ );
		}
	}

	HANDLE get() { return handle_; }

private:
	HANDLE handle_;
        auto_file_handle() {}
};

Это вспомогательный класс для того чтобы не забыть освободить хэндл открытого файла. При выходе из области видимости объект будет разрушен и деструктор закроет хэндл. Если бы конструктор не был бы объявлен explicit, то объекту можно было бы присвоить значение другого хэндла, вследсвие чего возникла бы утечка ресурсов.