AVC>>Но только (по крайней мере, в чистом виде) не выручит она Вас в случае с массивом. Ведь массив в Си/Си++ в качестве параметра синтаксически неотличим от указателя (т.е. и есть указатель). Чем же поможет Вам ASSERT применительно к указателю, просто указателю?

#include <cstdio>
#include <cassert>

void foo(int *p)
{
    assert(p != NULL); // для начала, перекрестясь, подстрахуемся с помощью assert; авось, поможет!
    // здесь какой-то код, работающий то ли с массивом, то ли с указателем.
    printf("%d\n", p[1023]); // например, так; ах, я кажется вышел за границу массива... но откуда мне было знать?
    delete p; // или так; ой, я "удалил" стековую переменную... какой все-таки Си++ сложный!  :) 
}

int main()
{
    int a[10]; // массив
    int *p;    // указатель;
    
    foo(a); // передаем массив
    p = new int;
    foo(p); // передаем указатель на int
    p = new int[10];
    foo(p); // передаем указатель (или все-таки массив? :) )
    return 0;
}

Недаром люди говорят:
Солдат — всегда солдат!

PROCEDURE foo(VAR p: ARRAY OF INTEGER);
  VAR i: LONGINT;
BEGIN
  FOR i := 0 TO LEN(p)-1 DO
    Out.Int(p[i], 0); Out.Ln; (* совершенно безопасно *)
  END:
  p := NIL; (* ошибка компиляции *)
  NEW(p);   (* ошибка компиляции *)
END foo;

AVC>>А вообще-то, у нас здесь языковой флейм потихоньку (не все сразу ) сходит "на нет".

AVC>>Оказывается, можем мы все-таки понимать друг друга.

CX>

#include <cstdio>
#include <cassert>

template <size_t N>
void foo(int (&p)[N])
{
    assert(p != NULL); // для начала, перекрестясь, подстрахуемся с помощью assert; авось, поможет!
    // здесь какой-то код, работающий то ли с массивом, то ли с указателем.
    printf("%d\n", p[1023]); // например, так; ах, я кажется вышел за границу массива... но откуда мне было знать?
    delete p; // или так; ой, я "удалил" стековую переменную... какой все-таки Си++ сложный!  :) 
}

int main()
{
    int a[10]; // массив
    int *p;    // указатель;
    
    foo(a); // передаем массив
    p = new int;
    foo(p); // передаем указатель на int
    p = new int[10];
    foo(p); // передаем указатель (или все-таки массив? :) )
    return 0;
}

AVC>Надеюсь, мы все-таки переросли эту детскую "болезнь левизны".

AVC>>>А вообще-то, у нас здесь языковой флейм потихоньку (не все сразу ) сходит "на нет".

AVC>>>Оказывается, можем мы все-таки понимать друг друга.

CX>>

AVC>Взаимно!

AVC>Все как-то не хватает — то времени, то сосредоточенности...

... << RSDN@Home 1.1.4 beta 7 rev. 447>>

CX>Может, перейдем на ты? Удобнее, да и форуму соответствует.

CX>#include <cstdio>
CX>#include <cassert>

CX>template <size_t N>
CX>void foo(int (&p)[N])
CX>{
CX>    assert(p != NULL); // для начала, перекрестясь, подстрахуемся с помощью assert; авось, поможет!
CX>    // здесь какой-то код, работающий то ли с массивом, то ли с указателем.
CX>    printf("%d\n", p[1023]); // например, так; ах, я кажется вышел за границу массива... но откуда мне было знать?
CX>    delete p; // или так; ой, я "удалил" стековую переменную... какой все-таки Си++ сложный!  :) 
CX>}

CX>int main()
CX>{
CX>    int a[10]; // массив
CX>    int *p;    // указатель;
    
CX>    foo(a); // передаем массив
CX>    p = new int;
CX>    foo(p); // передаем указатель на int
CX>    p = new int[10];
CX>    foo(p); // передаем указатель (или все-таки массив? :) )
CX>    return 0;
CX>}
CX>

CX>И попробуй скомпилировать это нормальным компилятором (Comeau C++ online подойдет). Узнаешь много нового

    p = new int[10];
    foo(p); // передаем указатель (или все-таки массив? :) )

AVC>    p = new int[10];
AVC>    foo(p); // передаем указатель (или все-таки массив? :) )
AVC>

AVC>так и не скомпилировался. А ведь вроде бы — чем не массив?

template<class T>
class array_t
{
  typedef T* iterator; // кому хочется - прикручивайте онлайновые проверки
  size_t size() const { return e_-b_; }
  iterator begin() const { return b_; }
  iterator end() const { return e_; }

  array_t(T* b, T* e) : b_(b), e_(e) { assert(b && e && b<=e); }

  template<int N>
  array_t(T (&arr)[N]) : b_(arr), e_(arr+N) {}
private:
  T *b_, *e_; // наследие Си - массив как указатель - тщательно спрятано
};

template<class T>
array_t<T> array(T* arr, int N) { return array_t<T>(arr,arr+N); } // для явного приведения; пользоваться только в случае крайней нужды!

template<class T>
array_t<T> array(T* arr, T* end) { return array_t<T>(arr,end); } // для явного приведения; пользоваться только в случае крайней нужды!

template<class T>
array_t<T> new_array(size_t n) { T* arr=new T[n]; return array_t<T>(arr,arr+N); } // создавать динамически? извольте-с

template<class T>
void delete_array(array_t<T> arr) { delete[] arr.begin(); } // ну там френды-шменды, разумеется. Не так уж влоб

void foo(array_t<int> arr); // это нешаблонная функция

int main()
{
  int x[10];
  int* y = x; // бардак-с! тяжкое legacy наследие

  array_t<int> z = new_array(10);

  foo(x);
  foo(array(y,10));
  foo(z);

  delete_array(z); // это мы по-простому, без умных указателей.
}

AVC>>    p = new int[10];
AVC>>    foo(p); // передаем указатель (или все-таки массив? :) )
AVC>>

AVC>>так и не скомпилировался. А ведь вроде бы — чем не массив?

int (*p)[10] = ((*)[10]) new int[10]; // радует также возможность употребить одну и ту же константу трижды :)

PROCEDURE foo(a: ARRAY OF INTEGER);
BEGIN
END foo;

PROCEDURE test_foo(size: INTEGER);
  VAR a: ARRAY 10 OF INTEGER;
    p: POINTER TO ARRAY OF INTEGER; (* указатель на открытый массив *)
BEGIN
  foo(a);       (* все хорошо *)
  NEW(p, size); (* создаем массив заранее неизвестного размера *)
  foo(p^);      (* все еще лучше :) *)
END test_foo;

template <size_t N>
void foo(int (&p)[N])
{
}

void test_foo(size_t size)
{
    int a[10];
    int (*p)[size] = (int (*)[size]) new int[size];
    foo(a);
    // пока все хорошо
    foo(*p); // а здесь у меня случился кряк: внутренняя ошибка компилятора 243
}

Internal compiler error 243.

К>template<class T>
К>class array_t
К>{
К>  typedef T* iterator; // кому хочется - прикручивайте онлайновые проверки
К>  size_t size() const { return e_-b_; }
К>  iterator begin() const { return b_; }
К>  iterator end() const { return e_; }

К>  array_t(T* b, T* e) : b_(b), e_(e) { assert(b && e && b<=e); }

К>  template<int N>
К>  array_t(T (&arr)[N]) : b_(arr), e_(arr+N) {}
К>private:
К>  T *b_, *e_; // наследие Си - массив как указатель - тщательно спрятано
К>};

К>template<class T>
К>array_t<T> array(T* arr, int N) { return array_t<T>(arr,arr+N); } // для явного приведения; пользоваться только в случае крайней нужды!

К>template<class T>
К>array_t<T> array(T* arr, T* end) { return array_t<T>(arr,end); } // для явного приведения; пользоваться только в случае крайней нужды!

К>template<class T>
К>array_t<T> new_array(size_t n) { T* arr=new T[n]; return array_t<T>(arr,arr+N); } // создавать динамически? извольте-с

К>template<class T>
К>void delete_array(array_t<T> arr) { delete[] arr.begin(); } // ну там френды-шменды, разумеется. Не так уж влоб

К>void foo(array_t<int> arr); // это нешаблонная функция

К>int main()
К>{
К>  int x[10];
К>  int* y = x; // бардак-с! тяжкое legacy наследие

К>  array_t<int> z = new_array(10);

К>  foo(x);
К>  foo(array(y,10));
К>  foo(z);

К>  delete_array(z); // это мы по-простому, без умных указателей.
К>}
К>

CX>>Может, перейдем на ты? Удобнее, да и форуму соответствует.

AVC>С удовольствием.

AVC>Да и то правда — какое там "Вы", когда Ариан-5 все-таки упал!

AVC>Стыжусь, но я действительно этого не знал!

AVC>Comeau C++ online не потребовался — уже второй домашний компилятор Си++ (GNU C++) с этим справился.

AVC>    p = new int[10];
AVC>    foo(p); // передаем указатель (или все-таки массив? :) )
AVC>

AVC>так и не скомпилировался. А ведь вроде бы — чем не массив?

"ComeauTest.c", line 9: warning: subscript out of range
      printf("%d\n", p[1023]); // например, так; ах, я кажется вышел за границу массива... но откуда мне было знать?

AVC>int (*p)[10] = ((*)[10]) new int[10]; // радует также возможность употребить одну и ту же константу трижды :) 
AVC>

vector<int> *p = new vector<int>(10);
// Конечно же, удалить тоже надо не забыть. А лучше всего воспользоваться смарт-пойнтером. Например, так:
auto_ptr<vector<int> > p(new vector<int>(10));
// Вот тут даже удалять не надо. Но остается проблема с семантикой передачи владения у auto_ptr.
// Хорошо, сделаем так:
boost::shared_ptr<vector<int> > p(new vector<int>(10));
// Тут уже можно копировать сколько угодно и куда хочешь. Но как же быть, если хочется избежать оверхеда
// от дополнительного выделения памяти для счетчика? Например, используя linked_ptr от Максима Егорушкина
// или другие, обеспечивающие иное поведение. В общем, на выбор пожаловаться нельзя.

template <typename Array>
void foo(Array &p)
{
}

void test_foo(size_t size)
{
    vector<int> a(10);
    auto_ptr<vector<int> > p(new vector<int>(size));
    foo(a);  // Все работает
    foo(*p); // И здесь тоже!
}

AVC>К чему бы это? Наверное, к дождю. Уже голова болит от того, что даже такая мелочь здесь проблема.

if(x==0) a0 = a0+1;
if(x==1) a1 = a1+1;
...
if(x==99) a99 = a99+1;
// вместо
if(x>=0&&x<=99) ++a[x];