>>Я бы сказал, что да. Примитивные типы = 0 а объекты
>>своими конструкторами
>>
>>В принципе я предпочитаю инициализировать их явно :)
>>
>>Успехов
>>--- sas
>
>
>Так ты бы сказал или оно так и есть???
>если б стат член инициализировался нулём можно было бы не инециализировать его
>явно а в конструкторе проверять - если 0 - инициализируем если
>не ноль то ничего не делаем
У вас совершенно неправильная трактовка ответа::
Рассмотрим несколько примеров используя 2 файла ttt.hh и ttt.cxx
с ошибками разного типа и без них
Вариант 1:
static члены объявлены но не определены и не инициализированны
(хотя бы один)
// --- ttt.hh ---------------------------------------
#ifndef __ttt_hh__
#define __ttt_hh__
#include <iostream>
using std::cout;
using std::endl;
class Demo {
// Только объявлены
static int i_;
static bool b_;
public:
void print()
{
cout << "i_ = " << i_ << "\n"
<< "b_ = " << b_ << endl;
}
};
// --- ttt.cxx ---------------------------------------------
#include "ttt.hh"
// Нельзя не инициализировать static члены //
int main()
{
Demo d;
d.print();
return 0;
}
Этот пример не будет слинкован из-за Uninitialized static members
Те мы объявили но не определили :(
==============================================
Вариант 2
Пытаемся инициализировать static член в конструкторе и .... не получается... Почему? А потому что статические члены должны быть инициализированы до этого. На самом деле они инициализируются даже до начала выполнения main
// --- ttt.hh ---------------------------------------
#ifndef __ttt_hh__
#define __ttt_hh__
#include <iostream>
using std::cout;
using std::endl;
class Demo {
// Только объявлены
static int i_;
static bool b_;
public:
Demo() { i_ = 123; }
void print()
{
cout << "i_ = " << i_ << "\n"
<< "b_ = " << b_ << endl;
}
};
// --- ttt.cxx ---------------------------------------------
#include "ttt.hh"
// Нельзя не инициализировать static члены //
int main()
{
Demo d;
d.print();
return 0;
}
============================================
Вариант 3
Инициализируем static значениями по умолчанию
// --- ttt.hh ---------------------------------------
#ifndef __ttt_hh__
#define __ttt_hh__
#include <iostream>
using std::cout;
using std::endl;
class Demo {
// Только объявлены
static int i_;
static bool b_;
public:
void print()
{
cout << "i_ = " << i_ << "\n"
<< "b_ = " << b_ << endl;
}
};
// --- ttt.cxx ---------------------------------------------
#include "ttt.hh"
int Demo::i_;
bool Demo::b_;
int main()
{
Demo d;
d.print();
return 0;
}
После компиляции и выполнения получим что
i_ = 0; // как и для обычных static переменных
b_ = false; // false == 0 не правда ли?
=========================================
Вариант 4
Определим static а ПОТОМ
присвоим другое значение static члену в конструкторе... Будет работать
// --- ttt.hh ---------------------------------------
#ifndef __ttt_hh__
#define __ttt_hh__
#include <iostream>
using std::cout;
using std::endl;
class Demo {
// Только объявлены
static int i_;
static bool b_;
public:
Demo() { i_ = 123; }
void print()
{
cout << "i_ = " << i_ << "\n"
<< "b_ = " << b_ << endl;
}
};
// --- ttt.cxx ---------------------------------------------
#include "ttt.hh"
int Demo::i_;
bool Demo::b_;
int main()
{
Demo d;
d.print();
return 0;
}
После компиляции и выполнения получим что
i_ = 123; // должно быть так
b_ = false; // false == 0 не правда ли?
=============================================
Вариант 5
Добавим комплексные статические члены.
// --- ttt.hh ---------------------------------------
#ifndef __ttt_hh__
#define __ttt_hh__
#include <iostream>
using std::cout;
using std::endl;
class Class1 {
public:
void print() { cout << "Class1"; }
};
class Class2 {
std::string s_;
public:
Class2( const char* s ) : s_( s ) {}
void print() { cout << "Class2" << endl; }
private:
Class2() {}
};
class Class3 {
public:
void print() { cout << "Class3" << endl; }
private:
Class3( const Class3& other ) {}
void operator=( const Class3& other ) {}
};
class Demo {
// Definitions...
static int i_;
static bool b_;
static Class1 c1_;
static Class2 c3_;
static Class3 c3_;
public:
void print()
{
cout << "i_ = " << i_ << "\n"
<< "b_ = " << b_ << endl;
c1_.print();
c2_.print();
c3_.print();
}
};
// --- ttt.cxx ---------------------------------------------
#include "ttt.hh"
int Demo::i_;
bool Demo::b_;
// Если не определим static член (хотя-бы один) программа не
// слинкуется
Class1 Demo::c1_; // вызывается конструктор по
//умолчанию сгенеренный компилятором
Class2 Demo::c2_; // До тех пор пока не сделаем наш
// конструктор по умолчанию public или не
// уберем его вообще не сможем скомпилировать
Class3 Demo::c3_; // Если копиконструктор и оператор присваивания не
// public мы не можем использовать
// сгенеренный компилятором конструктор.
//
// Надо делать public конструктор по умолчанию!!!
// !!! Кроме того если класс имеет какие то другие
// конструкторы, то мы можем их использовать явно
//
// В этом случае наш конструктор по умолчанию может быть
// private/protected и мы не зависим от копи конструкторв и
// операторов присваивания :)
//
// Н-р: Class2 Demo::c2_( "SSSSSSSSSSSS" );
//
int main()
{
Demo d;
d.print();
return 0;
}
Ну вот вроде бы и все
ВАЖНОЕ ЗАМЕЧАНИЕ: Код не был скомпилирован!!! Могут быть ошибки
КОД ПРЕДНАЗНАЧЕН ДЛЯ ПОЯСНЕНИЯ!!!
Успехов в изучении С++
--- sas
Вариант для распечатки
Программирование под UNIX (Public)
on
22-Фев-03, 15:24 (MSK)
