GUID GUID_StudentStruct = __uuidof(StudentStruct);
  HRESULT hr;

  ATLTRACE("Содержание присланного массива.\n");
  TraceSafeArray(*student);

  CComPtr<IRecordInfo> spRecInfo;
  hr = GetRecordInfoFromGuids(LIBID_RecInf1Lib, 1, 0, 0, 
    GUID_StudentStruct, &spRecInfo);
  if(FAILED(hr))
    return hr;
  const iLBound = 2, iUBound = 10;
  LPSAFEARRAY psaStudent = SafeArrayCreateVectorEx(VT_RECORD, iLBound, 
    iUBound - iLBound + 1, spRecInfo);
  if(!psaStudent)
    return E_FAIL;
  StudentStruct * pStudentStruct = NULL;
  hr = SafeArrayAccessData(psaStudent, (void**)&pStudentStruct);
  if(FAILED(hr))
    return hr;

  USES_CONVERSION;
  TCHAR szBuff[100];
  for(int i = 0, i2 = iLBound; i <= iUBound - iLBound; i++, i2++)
  {
    wsprintf(szBuff, _T("Имя %d"), i2);
    // Работаем со структурой, как будто она родная, C++-ая.
    pStudentStruct[i].name = SysAllocString(T2OLE(szBuff));
  }
  hr = SafeArrayUnaccessData(psaStudent);
  if(FAILED(hr))
    return hr;

  SafeArrayDestroy(*student);
  *student = psaStudent;
  ATLTRACE("Содержание возвращаемого массива. \n");
  TraceSafeArray(*student);
  return S_OK;

Мне кажется, что языки, используемые нами для выражения своих идей, становятся частью нас самих, поэтому, если вы знаете только один язык, может показаться, будто сторонники других языков представляют опасность лично для вас. Мне представляется, что выход из этой ситуации – освоение других языков. Сомневаюсь, что можно быть профессионалом в области ПО и знать лишь один язык программирования. Может быть и экономическая причина: фундаментальные знания выходят за границы языка программирования в отличие от многих практических навыков. Поэтому, если я знаю только язык X и его наборы инструментов, а вы являетесь сторонником языка Y и его наборов инструментов, вы представляете угрозу для источника моего заработка. И вновь решение, как мне кажется, — в знании нескольких языков и наборов инструментов (а также твердое понимание фундаментальных концепций).

Портфелем знаний мы предпочитаем называть все факты, известные программистам об информатике, обалсти приложений, в которых они работают, и накопленный ими опыт. Управление портфелем знаний очень похоже на управление финансовыми портфелем.
Предложения по поддержке портфеля знаний:
— Учите (как минимум) по одному языку программирования каждый год.
— Читайте по одной технической книге ежеквартально.
— Читайте книги, не относящиеся к технической литературе.
— Экспериментируйте с различными операционными средами.
Важно продолжать инвестирование. Как только вы почувствуете, что освоили новый язык или фрагмент технологии, двигайтесь дальше. Изучайте другой.
Неважно, будете ли вы когда-либо использовать одну из этих технологий в проекте или даже не упомянете о них в своем резюме. Процесс обучения расширит ваше мышление, открывая вас для новых возможностей и новых путей в творчестве. "Перекрестное опыление" идей важно; попытайтесь применить выученные уроки к проекту, над которым вы работаете в настоящее время. Даже если в вашем проекте не используется некая технология, вы наверняка сможете позаимствовать некоторые идеи.

Как сказал Дэвид Грфйс (Gries) подход к программированию не должен определяться используемыми инструментами. В связи с этим он проводит различие между программированием на языке (programming in lanuage) и программирование с использованием языка (programming into language). Разработчики, программирующие «на» языке, ограничивают свое мышление конструкциями, непосредственно поддерживаемых языком. Если предоставляемые языком средства примитивны, мысли программистов будут столь же примитивными.
Разработчики, программирующие «с использованием» языка, сначала решают, какие мысли они хотят выразить, после чего определяют, как выразить их при помощи конкретного языка.

Эйнштейн неоднократно утверждал, что природа должна иметь простые объяснения, поскольку Богу не свойственны капризность и произвол. У программиста нет такого утешения: сложность, с которой он должен справиться, лежит в самой природе системы

Сложность программного обеспечения – отнюдь не случайное его свойство. Сложность вызывается четырьмя основными причинами: сложностью реальной предметной области, из которой исходит заказ на разработку; турдностью управления процессом разработки; необходимостью обеспечить достаточную гибкость программы; неудовлетворительными способами описания поведения больших дискретных систем.

Программирование – это прикладное искусство. Простейший его смысл заключается в следующем: заставить компьютер делать то, что вам нужно (или то, что нужно пользователю, работающему с вашей программой). Программист – он и слушатель, он и советник, он и переводчик и даже диктатор. Вы пытаетесь ухватить суть не совсем ясных требований и найти такой способ их выражения, что только машина сможет оценить их по достоинству. Вы пытаетесь задокументировать работу так, чтобы она была понятна другим, спроектировать ее так, чтобы другие могли на нее положиться. Кроме того, вы пытаетесь сделать все это вопреки безжалостному ходу стрелки часов, отсчитывающих время, отпущенное на проект. Каждый день вы совершаете по маленькому чуду.
Это непростая работа.
Многие предлагают вам помощь. Фирмы-поставщики инструментальных средств настойчиво говорят о чудесах, которые творят их программы. Мудрецы от методологии заверяют в том, что их средства гарантируют результаты. Каждый считает свой язык программирования лучшим из лучших, а операционную систему – панацеей.
Разумеется, эти утверждения неверны. Простых ответов не существует. Не существует такого понятия, как наилучшее решение, будь то инструментальное средство, язык или операционная система. Существует лишь некие системы, которые являются более приемлемыми при конкретном стечении обстоятельств.
И в этот момент на сцену выходит прагматизм. Стоит избегать обряда венчания с конкретной технологией, но при этом необходимо обладать подготовкой и опытом, настолько обширными, что это позволит выбрать верные решения в конкретных ситуациях. Ваша подготовка происходит из понимания основных принципов информатики, а опыт основывается на разнообразных практических проектах. Теория и практика сочетаются, придавая вам силу.

ifstream inputStream(filePath);
string currentString;
const regex expression("(\\w+)\\s(\\w+)\\s(\\w+)");
multiset<string> matched;
while(getline(inputStream, currentString))
{
  if (regex_search(currentString, expression))
    matched.insert(currentString);
}
copy(matched.begin(), matched.end(), ostream_iterator<string>(cout, "\n"));

ГВ>Замыкать можно ещё и значения. Значения указателей — в том числе и т.д., и т.п.

ГВ>Вот это: "Такие как ollv". Если бы ты сказал "некоторые", я бы согласился. А так ты едва ли не прямо сомневаешься в квалификации ollv, что порицается правилами форума.

ГВ>Известна также душещипательная история о скоростной резке Сталкера перед выходом (часть карт порезана, часть выброшена и т.д.) Думается, что вторая причина посущественнее остальных будет.

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

bool IsOdd (int i) 
{
  return i % 2 == 1;
}

int main () 
{
  vector<int> myvector;
  vector<int>::iterator it;

  myvector.push_back(10);
  myvector.push_back(25);
  myvector.push_back(40);
  myvector.push_back(55);

  it = find_if (myvector.begin(), myvector.end(), IsOdd);

  cout << "The first odd value is " << *it << endl;

  return 0;
}

using System;
using System.Console;

module Program
{
  Main() : void
  {
    def myvector = Collections.Generic.List([10, 25, 40, 55]);
    
    def it = myvector.Find(x => x % 2 == 1);
    
    WriteLine($"The first odd value is $it");
  }
}

Х>int _tmain(int argc, _TCHAR* argv[])
Х>{
Х>    DWORD ticks = GetTickCount();

Х>    for(int i=0; i<1000000; i++)
Х>    {        
Х>        int arr[64]; // вот ето действительно стандартный "аллокатор" на С++
Х>    }

Х>    printf("%d", GetTickCount() - ticks);
Х>    getchar();
Х>    return 0;
Х>}
Х>

static unsafe void Main(string[] args)
{
    var sw = new System.Diagnostics.Stopwatch();
    sw.Start();

    for (int i = 0; i < 1000000; i++)
    {
        int* ptr = stackalloc int[100];
    }

    Console.WriteLine(sw.ElapsedMilliseconds);
    Console.ReadKey();
}

V>>Садись, два.

- Stubs provide canned answers to calls made during the test, usually not responding at all to anything outside what's programmed in for the test. Stubs may also record information about calls, such as an email gateway stub that remembers the messages it 'sent', or maybe only how many messages it 'sent'.
— Mocks are what we are talking about here: objects pre-programmed with expectations which form a specification of the calls they are expected to receive.

G>Как провсетление наступит можно выложить сюда реализацию моков на С++

E>Это никому не требуется, кроме древних-предревних кучь...

#include <windows.h>

int _tmain(int argc, _TCHAR* argv[])
{
    DWORD ticks = GetTickCount();

    for(int i=0; i<1000000; i++)
    {        
        int* arr = new int[64];
        delete [] arr;
    }

    printf("%d", GetTickCount() - ticks);
    getchar();
    return 0;
}

static void Main(string[] args)
{
    var sw = new System.Diagnostics.Stopwatch();
    sw.Start();

    for (int i = 0; i < 1000000; i++)
    {
        var arr = new int[64];
        arr[0] = arr[1]; //иначе оптимизатор грохает цикл
    }
    GC.Collect();//чтобы быть уверенным что вся память освободилась

    Console.WriteLine(sw.ElapsedMilliseconds);
    Console.ReadKey();
}

function Сфера { return x*x + y*y + z*z; }
function XPlaneFunc { return x;}
function YPlaneFunc { return y;}
function ZZZFunc
{
    double xmy = x - y; return xmy - Math.Round(xmy, 1);
}
function Спираль
{
    double xk=x*20; double a=0.2; double b=1.5;
    double y1=y*b-a*Math.Sin(xk);
    double z1=z*b-a*Math.Cos(xk);
    return y1*y1 + z1*z1;
}
body Голова
{
    return XPlaneFunc(p) < 0.0 && Сфера(p) < 1.0 && !Шлиц;
}
body Spiral
{
    return  XPlaneFunc(p) > 0.0 && XPlaneFunc(p) < 1.75 && Math.Abs(Спираль(p)) < 0.5;
}
body Шлиц
{
    return XPlaneFunc(p) < -0.4 && YPlaneFunc(p) < 0.1 && YPlaneFunc(p) > -0.1;
}
body Strokes
{
    return (Math.Abs(0.5 - XPlaneFunc(p)) < 0.02
     || (XPlaneFunc(p) > 0.5 && Math.Abs(ZZZFunc(p)) < 0.005))
    && !Spiral && !Голова;
}
body All
{
    return Голова || Spiral || Strokes || Wall;
}
body Wall
{
    return XPlaneFunc(p) > 0.5 && !Strokes && !Spiral;
}
colors GetColor
{
    if(Голова) return Color.Blue;
    if(Spiral)return Color.Red;
    if(Strokes)return Color.Black;
    if(Wall)return Color.Gray;
    return Color.Transparent;
}

As user-interface folks know, perceived performance and actual performance can often be different things. I [Steven] remember when I was writing a portion of the Windows UI for Visual C++ and when I benchmarked against Borland C++ at the time, we were definitely faster (measured by seconds). However the reviews consistently mentioned Borland as being faster and providing feedback in the form of counts of lines compiled flying by. So I coded up a line count display that flashed a lot of numbers at you while compiling (literally flashy so it looked like it couldn't keep up). In clock times it actually consumed a non-zero amount of time so we got "slower" but the reviewers then started giving us credit for being faster. So in this case slower actually got faster.

MK>А то страшно стало! Быстрее всё всё всё в main переношу...

for (i/*глобальная переменная*/ = items.Count -1; i >= 0; --i /*непременно префиксная форма*/)

#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <assert.h>

const size_t block_size = 256;
const int pool_size = 1000;

char * pool;
bool * allocated;

void * operator new[](size_t size) {
    if(size > block_size)
        return malloc(size);

    if(!pool) {
        pool = (char*)malloc(pool_size * block_size);
        allocated = (bool*)malloc(pool_size * sizeof(allocated[0]));
        memset(allocated, 0, pool_size * sizeof(allocated[0]));
    }

    for(int i = 0; i < pool_size; ++i) {
        if(!allocated[i]) {
            allocated[i] = true;
            return pool + block_size * i;
        }
    }

    return malloc(size);
}

void operator delete[](void * mem) {
    char * mem_ch = (char*) mem;

    if(mem_ch < pool || mem_ch >= (pool + pool_size * block_size))
        return free(mem);

    size_t diff = mem_ch - pool;
    assert(diff % block_size == 0);
    int block_num = diff / block_size;
    assert(block_num < pool_size);
    allocated[block_num] = false;
}

int _tmain(int argc, _TCHAR* argv[])
{
    DWORD ticks = GetTickCount();

    for(int i=0; i<1000000; i++)
    {        
        int* arr = new int[64];
        delete [] arr;
    }

    printf("%d", GetTickCount() - ticks);
    getchar();
    return 0;
}

C>Можете мне не отвечать. Я ответ знаю. Ответьте себе. Если сможете, то поймете о чем идет речь. А не сможете — ну да и Бог с Вами.

ГВ>>Мммм... Дотнет его сам сгенерирует? Полностью? А за пивом он сгоняет?

ГВ>>Даже если говорить о приведённом примере, то где здесь тестирование сети/жёсткого диска/...? Тестируется соответствие реального и предполагаемого протокола работы (form a specification, итить!). Или ты думаешь, что под sendMessage имеется в виду send в сокет?

Модульное тестирование (англ. unit testing) — процесс в программировании, позволяющий проверить на корректность отдельные модули исходного кода программы. Идея состоит в том, чтобы писать тесты для каждой нетривиальной функции или метода.(Глупость в википедии никогда не надо искать долго, достаточно двух предложений. — прим. Г.В.) Это позволяет достаточно быстро проверить, не привело ли очередное изменение кода к регрессии, то есть к появлению ошибок в уже написанных и оттестированных местах программы, а также облегчает обнаружение и устранение таких ошибок.