ИТ блог

Пример работы InterlockedExchange

2011-08-31T10:27:00.000+04:00

long g_sum;



unsigned __stdcall ThreadFunc(void* argList){

  for(int i = 0; i<100000000; i++){

    g_sum++;

  }

  return 0;

}



int _tmain(int argc, _TCHAR* argv[])

{

  /* Запускаем 2 потока с одной и той же функцией */

  HANDLE hThreads[2];

  hThreads[0] = (HANDLE)_beginthreadex(NULL, 0, &ThreadFunc, NULL, 0, NULL);

  hThreads[1] = (HANDLE)_beginthreadex(NULL, 0, &ThreadFunc, NULL, 0, NULL);



  /* Ждем... */

  WaitForMultipleObjects(2, hThreads, TRUE, INFINITE);



  _tprintf(TEXT("sum: %d\n"), g_sum);



  CloseHandle(hThreads[0]);

  CloseHandle(hThreads[1]);

  return 0;

}

Скорее всего, результат будет всегда разный, между 100 и 200 миллионами (можно увеличить число операций). Если бы каждый поток блокировал g_sum от другого потока на время изменения, то мы бы получили ровно 200 миллионов.

Самое простое, что можно сделать для этого - заменить g_sum++ на InterlockedExchangeAdd(&g_sum, 1). Теперь результат всегда корректен. Блокировка происходит на уровне процессора.

Почему обычный инкремент работает некорректно?

g_sum++ эквивалентно:

  mov eax, g_sum;

  add eax, 1;

  mov g_sum, eax;

То есть, реально это несколько операций. И поток может быть прерван другим потоком после выполнения любой из них. Получается какая-то каша.

55. Как объявить в классе и проинициализировать статический константный массив?

2011-04-08T09:32:00.000+04:00

Как и другие статические константы

class A{
public:
  static const int arr[];
};

const int A::arr[] = {0,1,2,3,4};

54. Для чего нужны статические поля в классе? Как они определяются?

2011-04-08T08:27:00.000+04:00

Обычно, каждому объекту соответствуют собственные значения всех его полей. Также к полям класса относят статические поля (static data members, static class fields, class variables) — поля, общие для всех объектов класса.

Статические поля семантически не отличаются от обычных глобальных переменных, но они доступны только по квалифицированному имени (то есть с указанием имени класса), и поэтому, в отличие от глобальных переменных, не загромождают пространство глобальных имён.

wiki

class A{
public:
  static int i;
}

/* Обязательно нужно проинициализировать */
int A::i = 0;

int main(){
  A::i = 1;
}

53. Сколько операндов имеет операция индексирования []? Какой вид результата должна возвращать эта операция?

2011-04-02T22:11:00.000+04:00

a. Ровно один операнд (параметр).
б. С точки зрения компилятора ничего она не должна и может возвращать что угодно. Или вообще не возвращать. Однако, я бы обиделся на std::vector, если бы не смог присваивать значения таким образом:

std::vector a(10);
a[3] = 42;

Поэтому, крайне желательно возвращать некоторое lvalue по ссылке, например:

double& operator[](int i){return _lvalue_;}

52. Разрешается ли объявлять массив в качестве поля класса. Как присвоить элементам массива начальные значения?

2011-03-29T13:59:00.000+04:00

a. Можно, как и обычный локальный (статический или динамический) массив.
б. Только почленно меняя каждый элемент. Однако можно обнулить массив в списке инициализации: array().

Хорошо описано тут

51. Влияет ли наличие целочисленных констант-полей на размер класса?

2011-03-24T13:20:00.000+03:00

Конечно, ведь каждый объект будет хранить свою константу. Но если константа static, то она будет храниться в одном экземпляре для всех объектов класса, и не повлияет на размер объекта.

50. Для чего служит ключевое слово explicit?

2011-03-23T14:03:00.000+03:00

Чтобы запретить неявное преобразование типа, выполняемое конструктором. А вообще такой ворос уже был: 48. Как запретить неявное преобразование типа, выполняемое конструктором инициализации?

49. Какие проблемы могут возникнуть при определении функций преобразования?

2011-03-22T19:11:00.000+03:00

Опять повторюсь, все-таки операции преобразования, а не функции.
Можно столкнуться с неоднозначностью (пример спер):

struct Tiny{
  Tiny(int){}
  operator int();
};

int operator+(Tiny, Tiny);

int main() {
  Tiny tiny(1);
  cout << tiny + 2;
}

Компилятор негодует, он не знает то ли преобразовывать первое слагаемое в int (чтобы вызвать обычный operator+(int, int)), то ли второе в Tiny (operator+(Tiny, Tiny)).

Конечно еще существует вероятность случайного неявного преобразования.

Такой оператор следует определить только когда преобразование достаточно очевидно. Но, например, не следует добавлять operator double для вычисления длины вектора, сами же и запутаетесь.

48. Как запретить неявное преобразование типа, выполняемое конструктором инициализации?

2011-03-18T15:55:00.000+03:00

О конструкторе инициализации я писал в ответе на 46-й вопрос.
Для запрета нужно добавить ключевое слово explicit.

class A{
public:
  explicit A(B);
};

void f(A);

Тогда вызовы, типа f(b) (b экземпляр B) будут запрещены. Однако всегда можно воспользоваться явным преобразованием f(A(b)).

47. Для чего нужны функции преобразования? Как объявить такую функцию в классе?

2011-03-18T15:41:00.000+03:00

Я уверен, что имеется в виду "оператор преобразования".
Допустим, мы хотим реализовать некоторую цепочку преобразований для объектов классов A, B, C:
A → B → C
Во-первых, можно написать функции преобразования (ну это понятно).
Во-вторых, использовать конструктор (см. вопрос 46). Для этого нужно добавить конструкторы B::B(A) и C::C(B) и преобразовывать на здоровье. Хоть явно, хоть неявно, как в примере:

struct A{
};

struct B{
  B(const A&){};
};

struct C{
  C(const B&){};
};

int main() {
  A a;
  B b = a;
  C c = b;
}

Я не добавлял никаких операций в класс A, так как B сам преобразовывает A → B. Преобразованием B → C, занимается C. Но часто оказывается так, что нежелательно или невозможно добавить операцию в C, зато B знает как преобразовать себя в C. Тогда нужно использовать оператор преобразования.

struct A{
};

struct C{
};

struct B{
  B(const A&){};
  operator C(){};
};

int main() {
  A a;
  B b = a;
  C c = b;
}

Итак, мини-шпаргалка:

T → B        используем конструктор B::B(T)
    B → T    используем B::operator T()

46. Какой вид конструктора фактически является конструктором преобразования типов?

2011-03-11T17:03:00.000+03:00

Конструктор с одним параметром. Для чего это нужно? Допустим у класса A есть конструктор принимающий единственный параметр - объект класса B. И есть некоторая функция принимающая объект класса A.

class A{
public:
  A(B);
};

void f(A);

Если у нас есть экземпляр класса B, то мы можем воспользоваться конструктором A(B), создать объект A, и передать в функцию:

B b;
A a(b);
f(a);

Или, если a не нужен для других целей (будет создан временный объект класса A):

B b;
f(A(b));

Но можно еще проще:

B b;
f(b);

Это эквивалентно примеру выше. Компилятор рассуждает так: "Я не могу передать b в f(A), это разные типы, но может быть есть способ преобразовать b к A? Да, можно воспользоваться конструктором A, передав b. Тогда будет создан объект класса A, его и передам в функцию".

Это приведение бывает полезным. Например (Страуструп 11.3.5), для операций с комплексными числами. Вместо такой стопки функций:

complex operator+(complex, complex);
complex operator+(complex, double);
complex operator+(double, complex);

можно оставить всего одну (первую), если в Complex создать конструктор Complex(double)

45. Какие конструкции С++ разрешается использовать в списке инициализации качестве инициализирующих выражений?

2011-03-02T12:48:00.000+03:00

Что такое список инициализации? Инициализация членов класса путем явного вызова конструктора.

/* Класс реализующий комплексное число */
class Complex{
...
  Complex(float re, float im);
...
};

class Test{
  Complex a;
public:
  Test():a(3,-2){}
};

Встретил ответ, что используются lvalue, инициированные rvalue. Его нельзя счесть за правильный, разве что сделать кучу оговорок.

int a(1);
++a = 5;

++a это lvalue, так как префиксная операция инкремента возвращает ссылку на объект. Но это не инициализация, и мы не сможем добавить ++a в список инициализации. Но если вы видите, что lvalue инициируется rvalue (int a(1)), то такое можно добавить в список. И можно ли сказать, что a(3,-2) это lvalue инициированное rvalue?

Поэтому, я считаю, правильный ответ: в качестве инициализирующих выражений используются явные вызовы конструкторов.

44. В каком порядке инициализируются поля в классе? Совпадает ли этот порядок с порядком перечисления инициализаторов в списке инициализации конструктора?

2011-02-20T18:44:00.000+03:00

struct A1{
  A1(){cout<<1;}
};

struct A2{
  A2(){cout<<2;}
};

class B{
  A1 x;
  A2 y;
public:
  B():y(),x(){}
};

int main() {
  B b;
}

Сначала объявлен член x, затем y. А в списке инициализации обратный порядок. Посмотрим что важнее. Запускаем. Получим "12". Все верно, ведь инициализация происходит в порядке объявления их в классе, а не в списке инициализации (так написано в спецификации).

А еще MinGW предупреждает:

In constructor 'B::B()':
|18|warning: 'B::y' will be initialized after
|17|warning: 'A1 B::x'
|20|warning: when initialized here

y будет проинициализирован позже, чем x, несмотря на порядок в списке инициализации.

43. Каким образом разрешается инициализировать константные поля в классе?

2011-02-18T15:42:00.000+03:00

Я уже насписал в ответе на "42. Как объявить константу в классе? Можно ли объявить дробную константу?". Вкратце:

class A{
  const T i;
  static const T i1 = 1; /* Если T - неинтегральный тип, может не сработать */ 
  static const T i2;  /* Для неинтегральных типов здесь только объявить, а проинициализировать позже */
  A():i(const_value){}
};

const T A::i2 = const_value;

К интегральным типам относятся char, short, int и long.

Есть еще один способ создания констант в классе, это enum hack. Изменим пример из ответа на 42-й вопрос.

class Year {
  /*...*/
  enum {MIN_YEAR = 1900, MAX_YEAR = 2100};
  /*...*/
}

42. Как объявить константу в классе? Можно ли объявить дробную константу?

2011-02-17T13:15:00.000+03:00

Сначала нужно подумать, что может означать "константа в классе". Попробую использовать относительно реальные примеры, а не мой любимый "class A" :)

Первый случай

Допустим, мы пишем класс Polygon (многоугольник). Мы хотим, чтобы количество вершин задавалось при создании объекта.

class Polygon{
  int vertexes;
public:
  Polygon(int v):vertexes(v){}
}

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

const int vertexes;

Значение такой переменной можно задать только в списке инициализации конструктора, как и сделано в примере. А вот так даже и не пытайтесь:

Polygon(int v){vertexes = v;} /*ошибка*/

см. также Страуструп 10.4.6.1. "Необходимая инициализация членов"

Второй случай

У нас есть класс Year, и мы хотим, чтобы задаваемый год не выходил за границы диапазона

const int MIN_YEAR = 1900;
const int MAX_YEAR = 2100;
const int DEFAULT_YEAR = 2011;

class Year{
  int year;
public:
  Year(int y);
};

Year::Year(int y){
  if(y < MIN_YEAR || y > MAX_YEAR){
    y = DEFAULT_YEAR;
  }else{
    year = y;
  }
}

Хорошо было бы, если класс не молчал, а как-то предупреждал о выходе за пределы, например генерировал исключение, но это пока не важно. Я хочу поместить эти константы в класс. Способ из предыдущего примера явно не подходит. Тут явно напрашивается связь со статическими членами. Так и есть, можно использовать статические константные члены.

class Year{
  int year;
  static const int MIN_YEAR = 1900;
  static const int MAX_YEAR = 2100;
  static const int DEFAULT_YEAR;
public:
  Year(int y);
};

const int Year::DEFAULT_YEAR = 2011;

Year::Year(int y){
  if(y < MIN_YEAR || y > MAX_YEAR){
    year = DEFAULT_YEAR;
  }else{
    year = y;
  }
}

Обратили внимание, что DEFAULT_YEAR проинициализирован за пределами класса? Да, можно и так. А с дробными, согласно спецификации, только так.

Можно ли объявить дробную константу?

Вопрос относится ко второму случаю, с первым (класс Polygon) все нормально.
Дробную объявить можно, но проинициализировать только аналогично способу инициализации DEFAULT_YEAR. Однако в спецификации нет явного запрета на:

class A{
  static const double PI  = 3.1415;
}

MinGW на это не ругается, VS не знаю. Почему так сложно с дробными? Я и сам не понял, можно почитать ветку форума, там вроде все выяснили.

Сервис Connecting Bloggers

2011-02-15T10:34:00.000+03:00

Мы решили сделать сервис, которые делает тоже самое, автоматически, на основе информации из ваших блогов — мы берем ваши посты, выбираем картинки к ним (если картинки нет, то пытаемся найти в интернете подходящую) и генерируем информер, который вставляется в блог.
http://habrahabr.ru/blogs/blogosphere/113613/

Ради любопытства прикрутил виджет, его можно видеть справа. Автоматически подбирающиеся картинки, конечно не в тему, но иногда бывают забавными, пусть пока побудут.

Страуструп "Язык программирования C++". Специальное издание 2011.

2011-02-14T17:10:00.000+03:00

Забывал написать. Наконец-то переиздали. Заказал в декабре, получил 31-го, прямо под новый год.
На Озоне аж 924 рубля.
На books.ru - 622.
А я брал здесь за 684. Удобно, что посылку можно забрать в пункте выдачи заказов и там же оплатить по ее прибытии.

41. Как проинициализировать динамическую переменную?

2011-01-23T14:55:00.000+03:00

С помощью оператора new, а также его разновидностей.

Динамическая переменная может инициализироваться следующими способами:
1.

class A {/* определение класса */};
A* pa = new A(); /*Какой-либо конструктор.*/
delete pa; /*Не забываем освободить память*/

Динамическим может быть не только объект:

int* pi = new int(1);
cout << *pi;
delete pi;

2. placement new. Не выделяет память, а размещает объект в заранее определённом месте.

int i = 1;
int* j = new(&i) int(2); /*Разместили по томо же адресу, что и i.*/
cout << i << "\n"; /*Значение i затерто*/

3. nothrow new. В случае нехватки памяти, при вызове обычного new, им генерируется исключение std::bad_alloc. А new(nothrow) просто возвращает 0.

Пробежался по верхам, так как о new еще будут вопросы. А пока задам вопрос случайно заглянувшему читателю: бывает ли nothrow версия оператора placement new и почему?

40. Приведите несколько случаев, когда конструктор вызывается неявно.

2011-01-08T20:11:00.007+03:00

Приведение типа, передача по значению, копирование, конструирование внутренних объектов. Конструктор внутренних объектов вызывает сгенерированный конструктор по умолчанию, решил в примере не отражать, и так понятно :)

class A{
  int x;
public:
  A(){};
  A(int p):x(p){};
  A(A const& a){x = a.x;}
};

A f(A a){
  return 3; //это return A(3); пример 3.
}

A g(A a){ 
  return a; //Вызов конструктора копирования. пример 5.
}

int main(){
  A a;
  a = 1; /*это a = A(1); пример 1.*/
  f(2); /*это f(A(2)); пример 2.*/
  g(a); /*Вызов конструктора копирования. пример 4.*/
}

39. Может ли конструктор быть приватным? Какие последствия влечет за собой объявление конструктора приватным?

2011-01-08T17:31:00.000+03:00

Может. Конструктор нельзя будет вызвать (кроме как из члена этого класса), а значит создать объект будет невозможно, если не предусмотреть способ вызова конструктора из члена класса. Примечание: если мы объявили какой-нибудь конструктор, даже приватный, то конструктор по умолчанию создан не будет.
Используется, например, в реализациях паттерна singleton

38. Сколько конструкторов может быть в классе? Допускается ли перегрузка конструкторов? Какие виды конструкторов создаются по умолчанию?

2011-01-08T16:49:00.000+03:00

a. С разными параметрами сколь угодно.
b. Да. Они подчиняются тем же правилам разрешения перегрузок, что и обычные методы.
c. Конструктор по умолчанию (без параметров), конструктор копирования.

37. Дайте определение конструктора. Каково назначение конструктора? Перечислите отличия конструктора от метода.

2011-01-08T11:44:00.000+03:00

Ответ вкратце, благо информация по этому вопросу есть в любой книге.
a, b. Особый метод предназначенный для инициализации объектов класса.
c. Конструктор не возвращает значение, не наследуется

36. Дайте определение дружественной функции. Как объявляется дружественная функция? А как определяется?

2010-11-23T14:25:00.001+03:00

Функция может быть дружественнной не сама по себе, а только по отношению к другим классам. Функция дружественная классу - обычная функция, которой доступны скрытые и защищенные члены этого класса.

Объявляется и определяется точно так же как и обычная функция. Но чтобы объявить ее дружественной некоторому классу, этот класс сам должен указать у себя в объявлении этот факт ключевым словом friend

Пример:

class A{
friend void f(A& a);
int x;
};

void f(A& a){a.x = 1;}

35. Какие операции разрешается перегружать только как методы класса?

2010-11-23T13:45:00.000+03:00

= [] () ->

34. Какие операции не рекомендуется перегружать как методы класса? Почему?

2010-11-14T10:34:00.000+03:00

Даже и не знаю. Страуструп рекомендует перегружать как методы класса только те операторы, которым требуется изменить защищенные члены. Например:

class A{
  int x;
public:
  A& operator+=(int b){x+=b;} //Этому оператор изменяет защищенный член
}

//А этому не нужно менять, и он может воспользоваться оператором +=
A operator+(A& a, int b){A res = a; return res+=b;}

33. Что означает выражение *this? В каких случаях оно используется?

2010-11-14T10:18:00.000+03:00

Разыменованный указатель на себя. Часто используется, если функции-члену класса нужно вернуть ссылку на текущий объект:

class A{
  int x;
public:
  A& operator=(const A& a){x = a.x; return *this;} 
}

32. Как различаются перегруженная префиксная и постфиксная операции инкремента и декремента?

2010-11-14T10:08:00.004+03:00

Выражение ++a компилятор превращает в вызов operator++(a), а для a++ в вызов operator++(a, int). Параметр int добавлен только для различия сигнатур функций и его значение не используется. Аналогично для декремента.

31. Какой результат должны возвращать операции с присваиванием?

2010-11-14T10:07:00.000+03:00

Вообще говоря, ничего они не должны. Однако, для всех классов, по умолчанию, этот оператор означает копирование объекта и возвращение ссылки. Поэтому, при переопределении оператора, отступать от этого правила нежелательно. Но мы не обязаны использовать этот оператор только для копирования объектов.


class A{
public:
  int x;
  A& operator=(const A& a){x = a.x; return *this;} //переопределили стандартное поведение
  void operator=(int xx){x=xx;} //определили поведение при присваивании целого. Но здесь тоже можно вернуть *this.
};

int main(){
  A a;
  a=1;
  A a2;
  std::cout << (a2=a).x;
}

30. Перечислите особенности перегрузки операций как методов класса. Чем отличается перегрузка внешним образом от перегрузки как метода класса?

2010-10-29T16:26:00.000+04:00

Первый параметр оператора опускается, им становится экземпляр класса (this).
Его можно сделать константным методом.
У него имеется доступ к не-public членам.
Оператор можно сделать виртуальным.

Этим и отличается.

29. Можно ли определить новую операцию?

2010-10-27T20:44:00.000+04:00

Нельзя. Технически это было бы несложно, но создало бы больше проблем, чем решило. Допустим, мы решили добавить операцию **, означающую в некоторых языках возведение в степень. Посмотрим, какие возникают трудности.

Неоднозначность. Как интерпретировать a**b? (a)**(b) или a*(*b). Заметьте, оба варианта синтаксически корректны, но имеют разный смысл. Придется создавать правила для разрешения этой ситуации.
Ассоциативность. Чему эквивалентно a**b**c? (a**b)**c или a**(b**c)?
Приоритет. Чему эквивалентно a+b**c? (a+b)**c или a+(b**c)?

Напоминаю, с точки зрения разработчика языка, проблемы не являются неразрешимыми. В некоторых языках есть такая возможность.

28. Можно ли при перегрузке изменить приоритет операции?

2010-10-26T20:23:00.000+04:00

К счастью, нет :) Это создало бы слишком много проблем.

27. Можно ли перегружать операции для встроенных типов данных?

2010-10-25T22:39:00.000+04:00

Нет. Вообще, хотя бы одно из значений оператора должно являться пользовательским типом.

26. Какие операции нельзя перегружать? Как вы думаете, почему?

2010-10-24T18:49:00.000+04:00

По-моему, чаще используется слово "оператор", я так и буду их называть.
Перегружать можно следующие операторы:

+ - * / % ^ & | ~ ! = < >
+= -= *= /= %= ^= &= |=
<< >> >>= <<= == != <= >=
&& || ++ -- ->* , -> [] ()
new new[] delete delete[]

А нельзя (подсмотрел у Страуструпа):

:: (разрешение области видимости)
. (выбор члена)
.* (выбор члена через указатель на член)
?: тернарный оператор
sizeof, typeid

У первых трех в правой части имя, а не значение. У тернарного оператора аж 3 параметра, к тому же его возвращаемое значение является l-value. Переопределять sizeof, typeid, думаю, просто нет смысла.
Также нельзя определить новые лексемы.

Размер объекта (класса). Что на него влияет.

2010-10-23T19:43:00.001+04:00

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

Нестатические члены
Выравнивание
Наличие виртуальных методов (+размер указателя на таблицу виртуальных методов)
Количество виртуально пронаследованных классов в иерархии наследования (+размер указателя на таблицу виртуальных методов каждого такого класса)

Вот и все.

25. Одинаков ли размер класса и аналогичной структуры?

2010-10-23T13:56:00.000+04:00

Да. У структуры всего одно отличие: доступ к членам по умолчанию открыт (public)

см. также:
6. Является ли структура классом? Чем класс отличается от структуры?
10. Для чего используются ключевые слова public и private?

24. Влияют ли методы на размер объекта?

2010-10-22T23:42:00.001+04:00

Нет. Метод класса един для всех объектов класса, и разумеется, не создается каждый раз при создании объекта.

см. также:
14. Что такое метод? Как вызывается метод?

23. Каков размер «пустого» объекта?

2010-10-21T22:15:00.000+04:00

class A{
}

В теории не меньше одного байта. На практике ровно один байт. Не ноль потому, что, согласно спецификации, каждый объект должен иметь свой адрес. Объекты с нулевым размером запросто могли иметь один и тот же адрес.

22. Сколько места в памяти занимает объект класса? Как это узнать?

2010-10-20T17:51:00.001+04:00

sizeof()

21. Объясните принцип полиморфизма.

2010-10-19T15:51:00.003+04:00

Неинтересный вопрос. В том смысле, что в двух словах не рассказать, а расписывать подробно не хочу. О полиморфизме и так много информации в книгах и интернете. Понравилось в Википедии: Кратко смысл полиморфизма можно выразить фразой: «Один интерфейс, множество реализаций». И от себя неплохой, как мне кажется, примерчик.

class Animal{
public:
  virtual string voice() = 0;
};

class Cat: public Animal {
public:
  string voice(){return "Мяу!";}
};

class Dog: public Animal {
public:
  string voice(){return "Гав!";}
};

void printVoice(Animal* animal){
  cout << animal->voice(); //Здесь происходит полиморфизм. 
}

int main()
{
  Animal* animal1 = new Cat;
  Animal* animal2 = new Dog;

  printVoice(animal1);
  printVoice(animal2);

  delete animal1;
  delete animal2;
}

20. Может ли константный метод вызываться для объектов-переменных? А обычный метод — для объектов-констант?

2010-10-18T20:41:00.002+04:00

Проще всего посмотреть самому:

class A{
public:
  void f1() {}
  void f2() const {}
};

int main()
{
  A a;
  const A& ac = a;

  a.f1();
  a.f2();
  ac.f1(); //ошибка!
  ac.f2();
}

Вывод: нельзя вызывать неконстантные функции константных объектов. Но деструктор можно.

19. Зачем нужны константные методы? Чем отличается определение константного метода от обычного?

2010-10-17T21:17:00.003+04:00

a. Для отмечания факта, что метод не изменяет члены класса. Компилятор пресечет попытки такого случайного вмешательства. Следующий вопрос посвящен вызову константных методов.
b. void A::f() const {/*...*/}

18. Что обозначается ключевым словом this?

2010-10-16T21:56:00.002+04:00

В каждой нестатической функции-члене класса this является указателем на объект, для которого вызвана функция. Страуструп пишет, что это не совсем обычная переменная и невозможно получить ее адрес. Мне не очень понятно это ограничение. Тем более, программа, откомпилированная MinGW, прекрасно вывела этот адрес.

17. Можно в методах присваивать параметрам значения по умолчанию?

2010-10-15T22:48:00.004+04:00

Так же, как и в обычных функциях.

Это можно сделать либо в объявлении класса:

class A { 
  int f(float c = 3.14);
}

Либо при определении функции:
int A::f(float c = 3.14);

Но не там и там одновременно.

Inline. Встроенные функции.

2010-10-15T20:35:00.002+04:00

Раз уж в 16 вопросе были упомянуты встроенные функции, думаю, хорошо было бы рассказать о них подробнее. Как уже сказано, компилятор будет пытаться заменять вызовы таких функций непосредственно на их определения. Например:


inline int plusOne(int n){
  return n+1;
}
/*...*/
int k=5;
cout << plusOne(k);

Компилятор заменит plusOne(k) на (k+1), подставив k вместо n в определении функции. Рассмотрим более интересный пример:


//рекурсивное вычисление факториала:
inline int fact(int n){
  return n!=1 ? n*fact(n-1) : 1;
}
/*...*/
cout << fact(3);

Действия компилятора с этим выражением по шагам:

cout << (3!=1 ? 3*fact(3-1) : 1); //заменил вызов определением
cout << 3*fact(2); //наш компилятор не дурак - упростил выражение
cout << 3*(2!=1 ? 2*fact(2-1) : 1); //заменил
cout << 6*fact(1); //упростил
cout << 6*(1!=1 ? 1*fact(1-1) : 1); //вызов fact уже не нужен, так как условие не выполняется.
cout << 6;

Теперь такое выражение:


cout << fact(100);

Что будет делать компилятор? Заменять вызов 100 раз? А если написать fact(1000)? А если так:


int k;
cin >> k;
cout << fact(k);

Опять рассмотрим по шагам:

cout << (k!=1 ? k*fact(k-1) : 1); //Это уже не упростить. Ладно, заменим fact(k-1)
cout << (k!=1 ? k*(((k-1)!=1 ? (k-1)*fact(k-2) : 1)) : 1); //Нда... Продолжаем?
cout << (k!=1 ? k*(((k-1)!=1 ? (k-1)*(((k-2)!=1 ? (k-2)*fact(k-3) : 1)) : 1)) : 1);

Ну все-все, хватит. Компилятор тоже не будет долго церемониться. Если глубина замен вызовов слишком велика, он плюнет на inline, и оставит вызов функции без замены.

16. Как определить метод непосредственно внутри класса? А вне класса? Чем эти определения отличаются?

2010-10-14T20:23:00.004+04:00

class A {
  int f(){return 0;}
}

class A {
  int f();
}

int A::f(){return 0;}

c. Эти классы практически идентичны, но есть небольшое отличие. Определение первого класса эквивалентено:

class A {
  int f();
}

inline int A::f(){return 0;}

То есть, оно отличается от второго наличием ключевого слова inline. Оно означает, что компилятор постарается(так как это не всегда возможно) заменить вызов этой функции его определением. Рекомендуется не использовать вариант a (желательно использовать эквивалентную запись), так как смешиваются "что делает класс" и "как это делает".

15. Может ли метод быть приватный?

2010-10-13T20:45:00.004+04:00

Конечно.
Представим функцию:


void A::save(){
  if(check()){
    commit();
  }
}

Перед принятием изменений происодит проверка, все хорошо и логично. Если бы нельзя было сделать commit() приватной, то пользователь данного класса мог бы напрямую вызвать commit() без проверки, что может быть опасно.

14. Что такое метод? Как вызывается метод?

2010-10-12T20:02:00.004+04:00

а. Функция, принадлежащая классу. Методу доступны все поля класса (которому он принадлежит).
б.

class A{
  public:
  void f(int p);
};

1. Допустим, есть объявление: A a;
a.f(5); //вызов

2. Если есть указатель на A (A* pa), то:
2а. (*pa).f(5); //вызов
2б. pa->f(5); //синтаксически более удобный и рекомендуемый вызов.

Дополнение:
При инициализации класса A, в памяти создается метод f. На низком уровне он представляет собой обычную функцию с дополнительным параметром this (указатель на объект, вызвавший функцию). Поэтому a.f(5) заменяется компилятором на что-то вроде:

A__f(&a, 5);

13. Обязательно ли делать поля класса приватными?

2010-10-11T23:16:00.003+04:00

Конечно нет (Обычно, если все поля класса открытые, класс объявляют с помощью struct, но это только по желанию)

12. Существуют ли ограничения на использование public и private в классе? А в структуре?

2010-10-10T10:50:00.002+04:00

Нет. Эти модификаторы(а также protected) могут следовать в любом порядке, и встречаться в определении класса более одного раза. Влияние модификатора продолжается до следующего модификатора или до конца класса.

11. Можно ли использовать ключевые слова public и private в структуре?

2010-10-09T20:38:00.001+04:00

Да

10. Для чего используются ключевые слова public и private?

2010-10-08T11:50:00.002+04:00

public и private (а так же protected) - модификаторы доступа.
Public – доступ открыт всем, кто видит определение данного класса.
Private – доступ открыт только для самого класса и друзьям (friend) данного класса.
Следует отметить, что public, private, protected могут означать и тип наследования.

9. Что такое композиция?

2010-10-07T22:42:00.002+04:00

С точки зрения объектной модели - использование объекта как поле другого объекта. Мы используем композицию в случае если объект является составной частью другого объекта.


class Car {
  Engine engine;
  Wheel wheels[4];
}

В таком случае составной объект является хозяином своих объектов-частей и ответственнен за их создание и удаление.

8. Объясните принцип инкапсуляции.

2010-10-06T19:47:00.004+04:00

Инкапсуляция - сокрытие реализации класса с целью сохраниния целостности. Управляем автомобилем вы можете крутить руль, нажимать педали, переключать передачи и кое-что по-мелочи. Вам нужна возможность, например, менять концентрацию воздуха в горючей смеси или интервалы подачи искры в свечах? Спасибо, не надо.

QtCreator. Задаем опции компилятора.

2010-10-06T13:28:00.002+04:00

В .pro файле нужно добавить один из параметров (-O2 только для примера):


QMAKE_CXXFLAGS += -O2 #опция будет включена во всех режимах компиляции.
QMAKE_CXXFLAGS_DEBUG += -O2 #только в режиме DEBUG
QMAKE_CXXFLAGS_RELEASE += -O2 #только в режиме RELEASE

Еще можно написать так:


CONFIG(debug, debug|release){
  # Debug
  QMAKE_CXXFLAGS += -Os
}else{
  # Release
  QMAKE_CXXFLAGS += -O2
}

А вообще все параметры можно посмотреть здесь

7. Какие ключевые слова в С++ обозначают класс?

2010-10-05T21:57:00.003+04:00

Ключевые слова - это зарезервированные идентификаторы.
and and_eq asm auto bitand bitor bool break case catch char class compl const const_cast continue default delete do double dynamic_cast else enum explicit export extern false float for friend goto if inline int long mutable namespace new not not_eq operator or or_eq private protected public register reinterpret_cast return short signed sizeof static static_cast struct switch template this throw true try typedef typeid typename union unsigned using virtual void volatile wchar_t while xor xor_eq

Из них class и struct обозначают класс.

QtCreator. Не удалось сохранить сессию: /Users/%username%/AppData/Roaming/Nokia/qtcreator/default.qws

2010-10-05T21:02:00.003+04:00

Такая ошибка появлялась у меня на Windows 7. Мой %username% - кириллический, и QtCreator, из-за проблем с кодировкой, не смог найти соответствующую папку в C:/Users. Желания заводить другого пользователя у меня не было. Пощелкав мышкой, по-кривому, но проблему решил. В QtCreator открываем: инструменты - параметры - вставка кода - основное. Видим поле "имя пользователя". У меня там крякозябры. "А-а-а", - в первый раз сказал я, и написал его нормально, по-русски. Облом, не сохраняет. Тогда я скопировал крякозябры, и создал папку с таким же именем в users. Облом. Ей еще понадобилось дать права всем на чтение и запись. Сейчас все хорошо.

6. Является ли структура классом? Чем класс отличается от структуры?

2010-10-04T14:18:00.002+04:00

а) Да
б)
класс обявленный как class имеет по умолчанию доступ private,
класс обявленный как struct имеет по умолчанию доступ public.

То есть, такие определения эквиваленты:


class A {
/* */
}

struct A {
private:
/* */
}

Больше отличий нет. На практике обычно структура используется как группировка переменных не требующих задавать поведение для них.

5. Как называется использование объекта одного класса в качестве поля другого класса?

2010-10-03T23:34:00.001+04:00

Агрегация. Часто используется ее частный случай - композиция (B - составная часть A, и, в таком случае, А отвечает за создание и уничтожение B)

4. Допускается ли передавать объекты в качестве параметров, и какими способами? А возвращать как результат?

2010-10-02T20:09:00.003+04:00

Так же, как и переменные основных типов - по ссылке(1) и по значению(2).
1. С передачей по ссылке все в принципе ясно: передали ссылку и продолжаем работать с тем же объектом как ни в чем не бывало. Но мне не очень нравится такой способ. Если в коде мы видим:


int x = 1;
f(x);

То мы не можем предугадать, как передан x и может ли измениться его значение в теле функции, так как определение может быть void f(int a) или void f(int &a). Та же неопределенность и при передаче объекта.
Отмечу, что возможности передачи по ссылке не было в C.

2. Если мы не хотим неопределенности, то можно просто передать адрес объекта объекта с помощью указателя (произойдет передача значения указателя). В таком случае код, возможно выглядит не так красиво, но мне нравится больше:


void f(A* a){/* разыменовываем: *a */}

A a;
f(&a);

При передаче объекта по значению будет передано содержимое объекта


void f(A a){/* разыменовываем: *a */}

A a;
f(a);

Будет вызван конструктор копирования.

Возврат результата производится аналогичными способами. Однако важно проследить за временем жизни объекта, иначе можно вернуть ссылку или указатель на уже несуществующий объект. При передаче по значению будет вызван конструктор копирования.

3. Разрешается ли объявлять указатель на объект? А указатель на класс?

2010-10-01T16:19:00.000+04:00

Я много писал об указателях. Ясно, что объявлять указатель на объект конечно же можно.
Вообще говоря, на физическом уровне указатель представляет собой 4 байта, хранящие некоторый адрес. Теоретически можно объявить указатель на все что угодно, что занимает место в оперативной памяти. Но класс не хранится в явном виде в памяти.

Но ради интереса можно подумать что представляет собой класс на низком уровне.


class A{
int x;
int f(){return 1};
}

Если класс не используется в программе, то компилятор, скорее всего пропустит это объявление. Но допустим мы создали объект: A a; но где лежит информация, что член x имеет тип int, и занимает 4 (на других платформах может и не 4) байта? В исходном коде. Именно оттуда компилятор берет эту информацию и генерирует соответствующий код.
А вот код функции f() действительно загружается в память. Она скорее всего будет иметь свой адрес. А может и не будет, например, если компилятор или автор решит сделать ее встроенной (inline).
Как видим, в явном виде класс не хранится.

2. Можно ли объявлять массив объектов? А массив классов?

2010-09-30T23:46:00.000+04:00

С массивом объектов все ясно:


  class A {
  public:
    int x;
  };

  A a[3];
  //либо динамически:
  //A* a = new A[3];
  //(важно не забыть delete[] a;)
  a[0].x = 1;
  a[1].x = 2;
  a[2].x = 3;

  std::cout << a[0].x << a[1].x << a[2].x;

Переходим к следующему подвопросу. В Delphi можно было провернуть такую штуку:


type

A = class
end;

A1 = class(A)
end;

A2 = class(A)
end;

classA = class of A;

var
  classArray : array[1..2] of classA;
  objArray : array[1..2] of A;
  i : Integer;

begin
 classArray[1] := A1;
  classArray[2] := A2;
  for i := 1 to 2 do
  begin
    objArray[i] := classArray[i].Create();
    ShowMessage(objArray[i].ClassName);
  end;
end;

То есть действительно реализовать некий массив классов (можно ли его так назвать?). В C++ я был не очень уверен и погуглил "массив классов". Можно сделать похожий механизм через порождающие фабрики. Но так как это не массив, в обычном понимании, и это только 2-й вопрос, то ответ - "нельзя".
А еще поиск ответа показал, что очень многие спрашивают про "массив классов" имея в виду "массив объектов". Значит первый вопрос (чем обличается класс от объекта?) вполне актуален :)

1. Что определяет класс? Чем отличается класс от объекта?

2010-09-29T23:15:00.002+04:00

Класс определяет структуру и поведение. Объект определяет состояние (наполнение структуры) и меняет его в зависимости от поведения, заданным классом.
Вопрос "Чем отличается класс от объекта?" задает экзаменатор студенту, когда пытается вытащить его на троечку. А студент даже не открывал первую страницу отксеренных лекций. Это примерно то же самое, что спрашивать: "А чем вот этот Тузик(см. рис.) отличается от биологического подвида "собака домашняя"?".

Большой список вопросов на знание C++

2010-09-24T10:12:00.004+04:00

http://www.rsdn.ru/forum/cpp/1870577.1.aspx
Целых 385 вопросов. От простых до очень сложных.
Буду отвечать понемногу, и помечать топики с ответами меткой "385"

QT интернационализация.

2010-08-08T23:06:00.000+04:00

Хорошие статьи о создании поддержки нескольких языков в приложении.
1. Qt — трудности перевода
2. Локализация и числительные

QT. Цвета виджета.

2010-08-07T22:54:00.007+04:00

QPalette p = MyLabel->palette();
p.setColor(QPalette::Window, Qt::black); //фон
p.setColor(QPalette::WindowText, Qt::red); //шрифт
MyLabel->setWidget(p);

все.

QT. QObject. Первые ошибки. Collect2: ld returned 1 exit status.

2010-08-06T22:10:00.002+04:00

В связи со срочностью написания приложения на QT, была бегло пролистана соответствующая книжка. За эту спешку поплатился кучей глупых ошибок. Решил собрать коллекцию таких, на которые MinGW невразумительно ругается :)

При работе с QObject, очень просто получить такое:
1. no matching function for call to 'QObject::connect(...)'
2. undefined reference to 'vtable for MyClass'
3. collect2: ld returned 1 exit status

Последняя ошибка на первом месте моего хит-парада неприятных ошибок :)

Итак, если мы хотим использовать объект QObject, нужно не забывать:

Определять классы, использующие макрос Q_OBJECT в заголовочном файле (а не cpp). Иначе схлопочем ошибки 1 и 3.
Вставлять макроса Q_OBJECT (Ошибка 1). Примечание: если собрать проект без этого макроса, потом вставить его и опять попробовать собрать, то можно получить ошибки 2 и 3. Нужно произвести чистку проекта (или тупо грохнуть папку с билдом. В QT Creator она по умолчанию-MyProject-build-desktop)
Наследоваться от QObject, или его производного класса (Ошибка 1).
Вставлять #include . Ошибки можно и не получить, но сигналы и слоты работать не будут.
Определять объявленные слоты, если не хотим получить ошибку 3. С этим я конкретно намучался. "collect2: ld returned 1 exit status" и все! Ну как тут понять, что я просто забыл написать тело для слота MyClass::mySlot(){/* */}

UPD (7.08.10 18:25):
Блин, мне было нужно смотреть консоль сборки (QT Creator). Я бы сразу увидел дополнительную информацию о причинах ошибки.

Еще 2 теста на Quizful

2010-07-07T21:46:00.002+04:00

Я просто был обязан их пройти :)

Pascal - Основы:
Правильных ответов: 13 / 16 (81 %) требуется: 12
Синтаксис 3 / 4 (75 %)
Управляющие конструкции 3 / 4 (75 %)
Процедуры и функции 2 / 3 (66 %)
Указатели и ссылки 1 / 1 (100 %)
Типы данных 4 / 4 (100 %)

Delphi 7 - Основы
Правильных ответов: 14 / 18 (77 %) требуется: 14
Синтаксис 4 / 4 (100 %)
Ход выполнения программы 2 / 3 (66 %)
Указатели и ссылки 2 / 3 (66 %)
Массивы 2 / 3 (66 %)
Классы и объекты 3 / 4 (75 %)
Остальные 1 / 1 (100 %)

Радует, что провалов нет.

"Это же БИБЛИЯ))) Не продам..."

2010-07-05T23:07:00.000+04:00

Таким был один из комментариев в местном сообществе, на мое предложение купить бумажную книгу Страуструпа :) Ее нигде нет. В Ozon'е, Books.ru, Bolero и в куче других нет. В электронном виде не интересно.

Сервис онлайн тестирования Quizful

2010-07-04T23:16:00.000+04:00

Про этот сервис я знал уже давно, если не ошибаюсь, прочитал про него на Хабре. После прочтения заглянул на него, ради интереса прошел какой-то тест. И только потому, что саморазвиваться мне не очень хотелось, я долго не возвращался туда. Но когда захотел проверить свои знания c++, сразу же вспомнил о нем. Итак, описание с сайта Quizful.net:

Проект Quizful предназначен для онлайн-тестирования специалистов в сфере информационных технологий. Quizful является community-driven сервисом и развивается во многом благодаря усилиям сообщества ИТ-специалистов.

Цель проекта - предоставить качественный бесплатный сервис, который бы не только проверял уровень имеющихся знаний, но и помогал в получении новых знаний.

То, что нужно. Сразу был выбран тест "C++ - Основы". И вот горькая правда: тест не пройден.

Правильных ответов: 11 / 20 (55 %) требуется: 15
Базовые понятия 2 / 5 (40 %)
Управляющие конструкции 3 / 3 (100 %)
Функции 2 / 3 (66 %)
Ссылки и указатели 3 / 3 (100 %)
Структуры и классы 0 / 4 (0 %)
Массивы 1 / 2 (50 %)

Я конечно очень расстроился, но комменты приободрили:

Отличный тест на знание C++! Я его 2 раза завалил - прошел только с 3-ей попытки, хотя программирую на нем уже 8 лет! После теста возникает непреодолимое желание схватить книгу Страуструпа и читать до посинения! Жаль что времени на это у меня нет и не предвидится :( А так Автору теста - 5!

До прохождения теста считал себя если не крутым, то неплохим знатоком С++, благо кодирую на нем уже года три, есть несколько завершенных проектов... но тест оказался "ушатом холодной воды" выявил кучу моих пробелов в теории - пройти его сумел только с 4го раза. Почувствовал себя невеждой. Срочно открыл книги Кернигана, Страуструпа и Майерса - сидеть мне с ними по вечерам месяц, пока не пройду без ошибок все тесты.

Значит все не так уж плохо. И не зря я долбил указатели, 3/3 - порадовало :)

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

Например: Что будет выведено на экран после выполнение данного фрагмента кода?
int x = 0;
int y = 0;

if (x++ && y++){
y += 2;
}

cout << x + y;

Не буду писать (но очень хочется, так как из-за этого я ответил неверно), что есть подвох - в программировании все строго.

Варианты ответа:
0 (84 / 368)
1 (77 / 368)
2 (103 / 368)
3 (12 / 368)
4 (91 / 368)
В скобках количество давших такой ответ и это самое любопытное :)

Планы

2010-01-01T20:35:00.001+03:00

Первый день нового года - отличный повод строить планы.

Для работы:
· В первую очередь (в первых месяцах), хотелось бы занятся изучением процесса разработки ПО.
· Администрирование Windows Server
· Нужно более хорошее знание Oracle, pl/sql.
· Основы информационной безопасности.

Для себя
· Основы Linux
· Основы Adobe Flash (просто интересно)

В конце года можно будет подвести итоги :D

Функция без явного определения

2009-10-01T21:21:00.002+04:00

Убойный для меня пример.

typedef int (*pf)(int, int); char c[] = {85,-119,-27,-117,69,12,3,69,8,93,-61,-112}; pf sum = (pf)c; //reinterpret_cast отказывается, поэтому так. cout << sum(2,3); //Вывод 5. * This source code was highlighted with Source Code Highlighter.

Теперь sum - функция сложения, являющаяся аналогом этой:
int sum(int a, int b){return a+b;}

Сначала я написал нормальную функцию sum, затем байт за байтом просмотрел ее содержимое в памяти. К сожалению sizeof к функциям неприменим, поэтому я, после sum, определил еще одну функцию, и предположил, что в памяти они тоже рядом. Их адреса различались на 12 байт.

UPD: Одной строкой:
cout << ((int (*)(int, int))"\x55\x89\xE5\x8B\x45\x0C\x03\x45\x08\x5D\xC3\x90")(2,3);

Функции

2009-10-01T21:20:00.002+04:00

Страуструп говорит, что с функцией можно сделать только две вещи, это вызвать ее и получить ее адрес. Я добавлю, для ясности, что этот адрес можно присвоить указателю на функцию и вызвать функцию с помощью этого указателя. Эти указатели не представляют собой что-то новое, они хранят адрес функции.

Повторюсь, что я веду этот блог не как учебное пособие, а пытаюсь объяснить самому себе сложные моменты (написание топика заставляет достаточно подробно вникнуть в суть), а так же необычные вещи удивившие меня. Еще я люблю очень маленькие(особенно в одну строчку :), но показательные примеры.

Вопрос которым я задался: можно ли вызвать функцию, имея только ее адрес хранящийся в long. Разумеется просто ради интереса, без практической пользы. Без reinterpret_cast обойтись явно не смогу. Еще понадобится тип функции.


char f(){return 'f';}

typedef char (*PF)(); //именно такой тип у f()

long a = reinterpret_cast<long>(f); //получаем число...
cout << (reinterpret_cast<PF>(a))(); //... говорим, что это число - указатель на функцию. Скобки () приводят вызову функции.

Константы

2009-09-26T20:16:00.002+04:00

У Эккеля не зря целая глава выделена под константы. В этой теме много интересного. Сейчас я хочу создать константу и подкопаться к ней через указатели.

const int a = 1;
int b;
cout << &a << &b; //У меня, при запусках, b всегда имеет адрес меньше(на 4 байта), чем a.
int* p = (&b+1); //Это адрес константы a
cout << *p //1
*p = 2; //Меняем
cout << a << endl << *p; //1 2

Вроде поменяли, однако a осталось прежним, но по ее адресу лежит число 2. Дело в том, что компилятор просто заменяет все вхождения a на 1, и обычно для этого не выделяет память. Но когда мы написали &a, компилятор все-таки выделил память для нее и записал туда значение. Но все-равно перед компиляцией заменил в коде a на 1. Память вроде бы пропадает впустую, ее даже можно изменить.

reinterpret_cast

2009-09-21T23:49:00.007+04:00

Мне нравится, когда в книге, сначала приводится пример программы с комментарием типа: «Ну что, видали как круто? Подбирайте челюсть со стола и читайте дальше, как это работает». Обожаю если примеры маленькие, например:

long a = 2829155;
cout << reinterpret_cast< char* >(&a);

Выведется строка «c++». Не отдам руку на отсечение, что у всех она будет именно такой, это требует дополнительного исследования.
В первой строке записали четырехбайтовое число. Затем взяли адрес переменной и нагло наврали компилятору, что этот адрес совсем не указатель на long. Это указатель на char. Как компилятор интерпретирует указатель на char? Как строку.
Почему именно «с++»? 2829155 == 0x002B2B63. То есть число 2829155 хранится в виде последовательности байт: 0x63(==99), 0x2B(==43), 0x2B(==43), 0x0(==0). Если посмотреть таблицу символов, то убедимся, что 99 это символ «c», а 43 – «+». Байт с нулем интерпретируется как конец строки.
Совсем нетрудно написать программу обратного преобразования, из строки в число
Я не смогу толково объяснить все тонкости reinterpret_cast, для этого есть учебники. Однако, точно могу сказать, что он запросто превращает указатель одного типа в указатель другого. А это влечет совершенно другую интерпретацию байтов памяти, в чем можно убедиться выше. Об опасностях нетрудно догадаться. Если в примере взять число побольше, то 4-й байт уже не будет равен нулю. Значит, приведенная к char* строка будет продолжаться до первого нуля, но уже неизвестно где он будет.
С классами тоже интересно.

class A {
  public:
  int i;
};
void main(){
  int b = 1;
  cout << (*reinterpret_cast< A* >(&b)).i; /*1*/
}

Тут говорится, что по адресу &b вовсе не число, а переменная класса A. Нужно ли говорить насколько это все опасно.

Массивы

2009-09-18T14:00:00.003+04:00

В C++ очень многие понятия связаны с указателями. Не знаю нравится мне это или очень нравится, но я все чаще говорю "ух ты, прикольно!". Если написать в Паскале

var z : array[1..3] of Integer;

то переменная z будет массивом и все тут. Словно обертка над более низкоуровневыми типами. Хотя, может быть, это не совсем верно. Массив в C++:

int z[3];

В памяти отводится место(непрерывное) для трех int, а переменная z - указатель на первый элемент. Квадратные скобки просто делают удобнее работу с указателями. А раз так, то для получения значения, можно писать не только z[i], а еще и *(z+i).

z[i] == *(z+i)
&z[i] == z+i

Иными словами: Берем адрес первого элемента массива (адрес это z). Следующий элемент находится на sizeof(int) байт (у меня 4) дальше. Но количество байт нам знать не нужно, так как компилятор в курсе, что z - указатель на int, поэтому z+1 указывает на sizeof(int) дальше чем z, т.е на следующий элемент массива (на z[1]). Аналогично и z+i.

Еще пример
int* p = z+1;
int* p = &z[1];
//Обе записи эквивалентны.
cout << p[2]; //p - не массив, просто квадратные скобки смещают указатель и сразу разыменовывают.

В этом примере p[1]==z[2].

2009-09-17T17:20:00.001+04:00

Каждая строка занимает память. Операция определения адреса применима не только к переменным.

cout << (long)&"Hello" << (long)&"World"; //4464640 4464646 (опять эти числа, почему всегда они)

Любопытно, если записать одинаковые слова:

cout << (long)&"Hello" << (long)&"Hello"; //4464640 4464640

то можно увидеть одинаковые адреса. Видимо компилятор произвел оптимизацию.

char* и строковые литералы

2009-09-14T23:28:00.005+04:00

Изучаю дальше.

char c = 'x';

char* pc = &c;

Все понятно, pc – указатель на переменную char. И тут внезапно! Оказывается можно так:

char* pc = ”Hello”;

cout << pc //Hello;

pc же вроде должна хранить адрес! Страуструп сказал, что так можно типа потому, что в языке C строковые литералы (это оказывается так по-научному называется) хранились именно так, через char*. А C++ должен поддерживать C. И Страуструпу тут все понятно и незачем останавливаться на этом подробно. Жаль я не он, и мне ничего не понятно. Мне не нравится, что char* ведет двойную жизнь. Сейчас будем разбираться.

Попробую посмотреть адрес, и разыменовать pc.

cout << pc << (long)pc << *pc; //Hello 4464640 H

Ага, pc выдает Hello, а когда я преобразовал ее к long, то она все-таки вернула адрес.

Отлично, *pc выдает символ H. Т.е. pc по-прежнему работает как указатель на char.

Интересно, где остальные символы слова.

Итак, я взял pc (а он все-таки хранит адрес, но при удобной возможности прикидывается строкой), прибавил к хранящемуся (слово было выговорено с только нескольких попыток) там адресу 1. В ячейке с адресом pc лежит ‘H’, очевидно предположить, что в следующей ячейке лежит 'e'. Чтобы узнать адрес следующей ячейки, нужно просто прибавить 1 (так как ячейка char равна байту). А чтобы извлечь ее значение, нужно сделать разыменование:

cout << *pc << *(pc+1) << *(pc+2) << *(pc+3) << *(pc+4); //Hello

Сейчас нарисую, память после:

char* pc = ”Hello”;

char* pc2 = ”World”;

Так получилось, что слова идут друг за другом. В следующий раз такого может не быть. Для этого случая верно выражение pc + 6 == pc2. Еще можно вытащить слово “World” не используя pc2

cout << *(pc+6) << *(pc+7) << *(pc+8) << *(pc+9) << *(pc+10); //World

Разумеется, в другой раз это может не прокатить.

Определить конец слова помогает ‘\0’. Если бы я был составителем задачника, то добавил задачу печати слова, используя *(pc+i) в цикле, пока не встретится ‘\0’.

А еще минздрав предупреждает: строковые литералы изменять нельзя. *(pc) = 'z'; вывалится с ошибкой во время выполнения.

Вообще говоря это устаревший способ, лучше использовать char c[] = “Hello”. Потом об этом напишу.

Указатели

2009-09-13T20:20:00.005+04:00

В двух словах.

int i = 7;
int* pi = &i; //Указатель на int. Проинициализирован адресом i.
int** ppi = &pi //Указатель на int*, т.е. указатель на указатель на int. Проинициализирован адресом pi.

Когда-то я не понимал, что физически, указатель - это переменная хранящая адрес. Вот и все. Взглянем на структуру памяти после выполнения вышеприведенного кода.

Прямоугольники символизируют ячейки памяти. Правее указаны их адреса. Разумеется адреса могут быть другими, при следующем запуске. Стрелки добавлены исключильно для наглядности.

Переменная i может хранить любое значение типа int. pi - адрес любой переменной int. ppi - адрес любой переменной типа int*(например адрес pi).

Все это легко проверяется. В моем примере:

cout << i << (long)&i; //7 2293572
cout << pi << (long)π //2293572 2293568
cout << ppi << (long)&ppi; //22968 2293564
cout << *pi << **ppi << (long)*ppi; //7 7 2293572

(long) - преобразование перед выводом. Без него адреса выводятся в шеснадцатеричном виде. * - операция разыменования. То есть *pi возвращает значение переменной, находящуюся по адресу pi. *ppi == pi == &i

Был еще сложный для меня момент: указатели на int и на int* (и вообще все указатели) так похожи, раз хранят только адрес. Почему же нельзя сделать просто указатель на переменную любого типа. Вообще говоря можно. Но в таком случае можно легко ошибиться. Например случайно указать на переменную int, и думать про себя, что это объект. А благодаря типизации, компилятор будет следить за этим, а среда разработки будет помогать автозавершением кода для более сложных типов.

Уф, пока писал и проверял, сам все понял :)

Перечислимые типы

2009-09-13T11:49:00.003+04:00

С этими типами посложнее, чем в Delphi. Самый простой пример:

enum colors{RED, GREEN, BLUE};

RED, GREEN, BLUE - константы, равные числам 0, 1, 2 соответственно. Их значения можно задавать самостоятельно:

enum colors{RED=0, GREEN=1, BLUE=9}; //Должны быть целыми

Использование достаточно очевидно:

colors x = GREEN; //z == 1
colors z = 9; //Ошибка компиляции.
colors z = colors(9); //А вот так все хорошо. z == BLUE
if (z = BLUE) {/* */};

Любопытно (по крайней мере для меня), что переменной z можно присвоить другое значение кроме этих трех:

colors z = 2; //Как мы уже выяснили - это ошибка компиляции
colors z = colors(2); // Так можно. z == 2

Интересно, в каких пределах можно задавать значения? У меня не сошлось со Страуструпом.

Он говорит, что выделяется непрерывный диапазон, в зависимости от минимального и максимального значения. Диапазон определяется минимальным количеством бит, требуемым для представления перечисления. Пример оттуда:

enum e2{a=3, b=9} //диапазон 0:15

Поэтому, по его словам, e2 f2 = e2(20) не определено.

Границы диапазонов связаны со степенями двойки, но я не буду переписывать точное правило. Размер sizeof не может превышать sizeof(int).

Не знаю почему, но как я не крутил, sizeof всегда был равен 4. По всей вероятности sizeof(enum) = sizeof(int).

Вывод, который я сделал: Перечислимый тип - это фактически тот же int, но с личными именами некоторых чисел

Консольный сапер

2009-09-12T23:21:00.006+04:00

Чтобы практиковаться мне был нужен компилятор и среда разработки. Microsoft Visual Studio не устраивал платностью. Есть бесплатный Visual C++ Express Edition, но без MFC. Остановился на распространенном варианте Code::Blocks + MinGW.

Для тренировки сделал сапера. Пишем столбец и строку, а в ответ получаем количество мин вокруг.

#include #include #include int main() { const int SIZE = 3; const int ALL_MINES = 3; bool m[SIZE+2][SIZE+2]; bool u[SIZE+2][SIZE+2]; for(int i=0; i<=SIZE+1; i++){ for(int j=0; j<=SIZE+1; j++){ m[i][j] = false; u[i][j] = false; } } srand(time(0)); int x, y; for(int i=1; i<=ALL_MINES; i++){ do{ x = rand() % SIZE + 1; y = rand() % SIZE + 1; }while(m[x][y]); m[x][y] = true; } int xCount = SIZE * SIZE - ALL_MINES; while(xCount != 0){ std::cin >> x >> y; int xMines = 0; if(m[y][x]){ std::cout << "fail" << std::endl; break; } for(int i=y-1; i<=y+1; i++){ for(int j=x-1; j<=x+1; j++){ if(m[i][j]){xMines++;} } } std::cout << xMines << std::endl; if (!u[y][x]){ xCount--; u[y][x] = true; } } if (xCount = 0){std::cout << "win" << std::endl;} for(int i=1; i<=SIZE; i++){ for(int j=1; j<=SIZE; j++){ std::cout << m[i][j]; } std::cout << std::endl; } return 0; } * This source code was highlighted with Source Code Highlighter.

Над кодом долго не думал :)

Страуструп. Размеры целочисленных типов.

2009-09-10T23:15:00.001+04:00

Я был в курсе, что книга для продолжающих. Во 2-й главе я занервничал. В 3-й начал паниковать. Эти главы с высоты птичьего полета охватывали процентов 70 из того, что я узнал из предыдущей книги. Что же будет дальше. Но все закончилось хэппи эндом, это был просто обзор возможностей языка :)

Наконец-то я понял в каких пределах могут отличаться фундаментальные типы в зависимосимости от платформы. Авторы любят предупреждать: "Внимание, размер типов может отличаться, обязательно это помните". А откуда я знаю какой размер может принять, скажем, тип int на другой платформе. 2 байта? 4?. А может, например 2 бита? Могу ли я быть уверен, что число 9000 влезет в int?

Но тут конкретно сказано: независимо от погоды типу char гарантируется 8 бит, для short - 16, long - 32. Хм, где же int. Cудя по sizeof(short) <= sizeof(int) <= sizeof(long) ему дадут 16 бит точно. У меня на 32-битной Висте и компилятором minGW для них выдало: 2, 4, 4. Ну да ладно, просто учту на будущее.

C++

2009-09-09T23:50:00.000+04:00

Так получилось, что я плохо знаю C++. Скажем так, чуть лучше уровня "Hello, World!". Если я хочу(а я хочу) писать прикладные программы, то просто обязан постигнуть его.

Это осознание пришло около 2-х недель назад. Я начал с поиска подходящей книги. В рунете первым делом вспоминают книгу Брюса Эккеля "Философия Java" (Thinking in Java). Вот и отлично, тем более она была куплена мною около полугода назад и аккуратно положена на полку. Я часто смотрел на ее красивую оранжевую обложку. Обложка мне нравилась. Вероятно потому, что оранжевый цвет считается самым антидепрессивным :) Иногда я прочитывал введение, через месяц забывал, и снова прочитывал. Начало введения было очень вдохновляющим, но к концу оно меня утомляло.

Но однажды я сел и стал читать. И за пару недель почти полностью ее прочитал. Мне понравилось, но новичку в программировании не рекомендую. Автор предполагает(и подчеркивает), что читатель знаком с языком C, и разъясняет только новое, появившееся в C++.

Честно говоря, мне приходилось читать ее очень медленно, вдаваясь в каждый пример, вдумываясь в каждое предложение. Понравилось, что почти нет "разжевывания" материала. Если не понимал, просто возвращался назад и врубался.

Стиль интересный, хочу перечитать. Но только после Страуструпа "Язык программирования С++", в котором я прочитал кучу введений и предисловий, а также главу "от редакции русского издания". Ходят легенды, что каждый программист должен ее прочитать.

2009-09-08T22:50:00.000+04:00

Итак, надо вспомнить, что я вообще знаю.

Первым в списке QBasic - на нем написаны моя первая, а также вагон других программ. Интересно, что самым трудным для меня был цикл for, сложнее чем do-loop с массивами. Но я был тогда в 5-м классе. Не могу не вспомнить одну из самых крупных, созданную в 8 классе - тетрис с 29 различными фигурками (в каждой от одного до пяти квадратиков). Впрочем с возможностью выбора набора.

В университете начал учить Pascal. Долго не мог врубиться в указатели, а особенно в реализацию списков с помощью них. Хотя у меня тогда не было интернета.

Там же изучил HTML, CSS, но средненько. Очень поверхностно ASP, 1С, PHP

Курсовики и диплом писал на Delphi и достаточно хорошо усвоил принципы ООП.

Универ дал не очень много практики, зато теперь я относительно хорошо подкован в теории :)

На работе продолжил писать на Delphi, поэтому сам язык знаю достаточно хорошо. Но для меня остаются тайной дельфовые вкладки компонентов с названиями типа SOAP, Corba и т. п.

На среднем уровне владею SQL, PL/SQL

Не буду упоминать то, с чем мало работал.

Наверняка о чем-нибудь забыл написать.

Самая большая дыра в моем образовании это плохое знание C++. Про это в другом топике.

Начало не знаю чего

2009-09-08T22:00:00.000+04:00

Читая ИТ- форумы, блоги, книги, статьи, слушая разговоры коллег, все чаще стал понимать, что ничего не понимаю. Завертелась мысль, что неплохо было бы изучить ~~все~~ хотя бы поверхностно как можно больше популярных технологий, языков программирования, и всего остального, что связано с ИТ. Может быть я не представляю всей сложности, но по крайней мере есть большое желание. К тому же очень не хотелось бы отставать в своем развитии. Поэтому, для начала, завел блог в котором буду писать о своих ~~трудностях, лени и т.п.~~ успехах :)