R>struct XXX
R>{
R>    XXX()
R>    {
R>        strcpy(data, "Hello");
R>    }

R>    char data[6];
R>};

R>XXX data[1000];
R>std::cout.write(reinterpret_cast<const char*>(&data[0]), sizeof(data));

struct X { X() { cout << "Hello" << endl; } };
int main() { X data[1000]; }

std::count << "1000 раз";

printf("текст\n");
printf("текст\n");
printf("текст\n");
printf("текст\n");
// ... и так 1000 раз

#include <stdio.h>
struct x{x(){printf("string\n");};};
template <class T> struct x2{x2(){T t1,t2;}};
template <class T> struct x5{x5(){x2<T> t1,t2;T t;}};
int main(int argc,char* argv[])
{
  x5<x5<x5<x2<x2<x2<x> > > > > > o;
  return 0;
}

struct XXX
{
    XXX()
    {
        strcpy(data, "Hello");
    }

    char data[6];
};

XXX data[1000];
std::cout.write(reinterpret_cast<const char*>(&data[0]), sizeof(data));

printf( "%s%s...%s", "text\n" );

template <int N>
void print_n(const char* str) {
    std::cout << str << std::endl;
    print_n<N - 1>(str);
}

template <>
void print_n<1>(const char* str) {
    std::cout << str << std::endl;
}

int main()
{
    print_n<1000>("some text");
    return 0;
}

int main()
{
  std::string s="string \n",
              s2=s+s,
              s4=s2+s2, 
              s8=s4+s4, 
              .... , 
              s512=s256+s256,
              s1024=s512+s512;
  std::cout<<s1024.substr( 0, s.size() * 1000 );
  return 0;
};

>     1000 $ 'hello '
> hello hello hello hello hello hello hello hello hello hell...
>

   1000 $,: 'hello'
hello
hello
hello
hello
hello
...

X say[1000];

#include <iostream>
#include <iterator>
#include <algorithm>
int main()
{
  std::fill_n(std::ostream_iterator<const char*>(std::cout, "\n"), 1000, "hello!");
}

perl -e 'print "string\n" x 1000'

#include <iostream>
template<int I>
struct A
{
static void f()    {
    A<I-1>::f();
    std::cout << "stroka\n"; 
    }
};
template<>
struct A<0>
{
    static void f(){}
};
int main(){
    A<1000> a;
    a.f();
}

while (true) std::cout << "Hello";

#define BODY(x, y, z) std::cout << "Привет";
BOOST_PP_REPEAT(BODY, 1000, _)

std::vector<const char*> data(1000, "Hello\n");
std::for_each(data.begin(), data.end(), std::cout << boost::lambda::_1);

#include <stdio.h>

void print_1() { printf("text\n"); }

#define DEF_PRINT(x,y) void print_##x() { print_##y(); print_##y(); }
DEF_PRINT(2,1)
DEF_PRINT(4,2)
DEF_PRINT(8,4)
DEF_PRINT(16,8)
DEF_PRINT(32,16)
DEF_PRINT(64,32)
DEF_PRINT(128,64)
DEF_PRINT(256,128)
DEF_PRINT(512,256)

int main()
{
  int const n = 1000;
  // мне лень раскладывать n по битам...
#define PRINT(x) (n & x) ? print_##x() : (void)0;
  PRINT(512);
  PRINT(256);
  PRINT(128);
  PRINT(64);
  PRINT(32);
  PRINT(16);
  PRINT(8);
  PRINT(4);
  PRINT(2);
  PRINT(1);
}

class XXX
{
public:
    XXX(int i, volatile int j=1)
    {
        j /= i;
        cout << "test" << endl;
        XXX a(i-1);
    }
};

int main()
{
    try
    {
        XXX a(4);
    }
    catch (...)
    {
    }
}

// с частичной специализацией

template<int N> struct F
{
  void f(const char* s)
  {
    F<N/2>::f(s);
    F<N-N/2>::f(s);
  }
};
template<> struct F<0>
{
  void f(const char* s) { }
};
template<> struct F<1>
{
  void f(const char* s) { cout << s << endl; }
};

int main() { F<1000>::f("hello"); }

// без частичной специализации

template<int N> struct int2type {};

template<int N> void f(const char* s, int2type<N> t)
{
  f(s,int2type<N/2>());
  f(s,int2type<N-N/2>());
}
void f(const char* s, int2type<0> t) {}
void f(const char* s, int2type<1> t) { cout << s << endl; }

int main() { f("hello",int2type<1000>()); }

void f(const char* s, int2type<0> t) {}
void f(const char* s, int2type<1> t) { cout << s << endl; }

template<int N> void g(const char* s, int2type<N> t)
{
  f(s, int2type<N%2>());
  g(s, int2type<N/2>());
  g(s, int2type<N/2>());
}
void g(const char* s, int2type<0> t) {}

// так
XXX::XXX(int N)
{
  if(N==0) throw int(0); // любой тип исключения, т.к. у нас универсальная ловушка
  cout << "hello\n";
}
// или так
XXX::XXX(int N)
{
  if(N==0) return;
  XXX x(N-1);
}
// или вот так
void f(int N)
{
  if(N==0) return;
  cout << "hello\n";
  f(N-1);
}

// print.h
#ifndef REPEAT_COUNTER
#define REPEAT_COUNTER 0
#endif

#if REPEAT_COUNTER < REPEAT_COUNT

#define REPEAT_COUNTER (REPEAT_COUNTER + 1)

PRINT_STRING
#include "print.h"

#endif

// main.cpp
#include <iostream>

#define REPEAT_COUNT        1000
#define PRINT_STRING        std::cout << "Hello, world!" << std::endl;

int main()
{
    #include "print.h"
}

d:\...\print.h(10): fatal error C1014: too many include files : depth = 1024

select 'hello' as dummy from ( select * from (select * from dual connect by dummy=dummy) where rownum<1001);

AD>select 'hello' as dummy from ( select * from (select * from dual connect by dummy=dummy) where rownum<1001);
AD>

 select 'hello'  from (select * from dual connect by dummy=dummy) where rownum<1001

    1000 $ 'hello '
hello hello hello hello hello hello hello hello hello hell...

class C {
public:
  C() { cout << "text\n"; }
};

int main {
  C c[1000];
}

IM>Это настолько древняя задача. Она уже везде перетерта 1000 раз.

IM>class C {
IM>public:
IM>  C() { cout << "text\n"; }
IM>};

IM>int main {
IM>  C c[1000];
IM>}
IM>

struct C {
  C()  { cout << "text\n"; }
  ~C() { cout << "text\n"; }
};

int main {
  C c[500];
}

printf("текст\n");
>printf("текст\n");
>printf("текст\n");
>printf("текст\n");
>// ... и так 1000 раз

>

    char *txt = "текст\n", *fmt = "%s%s%s%s";
    char s1[10*1024], s2[10*1024];
    sprintf(s1, fmt, txt, txt, txt, txt);
    sprintf(s2, fmt, s1,s1,s1,s1);
    sprintf(s1, fmt, s2,s2,s2,s2);
    sprintf(s2, fmt, s1,s1,s1,s1);
    printf(fmt, s2,s2,s2,s2);

Homo sum et nihil humani a me alienum puto...

class C
{
   private int i = 1000;
   ~C() 
   {
      if(--i >= 0)
      {
         Console.WriteLine("text here;");
         GC.ReRegisterForFinalize(this);
         GC.Collect(0);
      }
      else
         Console.ReadKey();
    }
}
        
static void Main(string[] args)
{
   C c = new C();
   c = null;
   GC.Collect(0);
}

template <int d> class Out : public Out<d-1> { public: Out() { std::cout << "Hello!"; } };
template <> class Out<0> {};

int main() { Out<1000> out; }

print "text\n"*1000

А>print "text\n"*1000
А>

А>

puts ["text"]*1000