What does the distance attribute in DMatches mean?

In this context, a feature is a point of interest on the image. In order to compare features, you "describe" them using a feature detector. Each feature is then associated to a descriptor. When you match features, you actually match their descriptors.

A descriptor is a multidimensional vector. It can be real-valued (e.g. SIFT) or binary (e.g. BRIEF).

A matching is a pair of descriptors, one from each image, which are the most similar among all of the descriptors. And of course, to find the descriptor in image B that is the most similar to a descriptor in image A, you need a measure of this similarity.

There are multiple ways to compute a "score of similarity" between two vectors. For real-valued descriptors, the Euclidean distance is often used, when the Hamming distance is common for binary descriptors.

As a conclusion, we can now understand the distance attribute: it is the score of similarity between the two descriptors of a match.

Usually when you are matching two features, you are actually comparing two vectors under certain distance metrics. Now let's assume your feature is SIFT with 128 dimensions, and you compare two SIFT features a and b using Euclidean distance, then DMatch.distance is equal to

int main()    
{    
	Mat img_1 = imread("111.jpg");    
	Mat img_2 = imread("112.jpg");    
	if (!img_1.data || !img_2.data)    
	{    
		cout << "error reading images " << endl;    
		return -1;    
	}    

	ORB orb;    
	vector<KeyPoint> keyPoints_1, keyPoints_2;    
	Mat descriptors_1, descriptors_2;    

	orb(img_1, Mat(), keyPoints_1, descriptors_1);    
	orb(img_2, Mat(), keyPoints_2, descriptors_2);    

	BFMatcher matcher(NORM_L2);
	vector<DMatch> matches;   
	matcher.match( descriptors_1, descriptors_2, matches );

	double max_dist = 0; double min_dist = 100;    
	//-- Quick calculation of max and min distances between keypoints     
	for( int i = 0; i < descriptors_1.rows; i++ )    
	{     
		double dist = matches[i].distance;    
		if( dist < min_dist ) min_dist = dist;    
		if( dist > max_dist ) max_dist = dist;    
	}    
	printf("-- Max dist : %f \n", max_dist );    
	printf("-- Min dist : %f \n", min_dist );    
	//-- Draw only "good" matches (i.e. whose distance is less than 0.6*max_dist )     
	//-- PS.- radiusMatch can also be used here.     
	std::vector< DMatch > good_matches;    
	for( int i = 0; i < descriptors_1.rows; i++ )    
	{     
		if( matches[i].distance < 0.5*max_dist )    
		{     
			good_matches.push_back( matches[i]);     
		}    
	}    
	
	Mat img_matches;    
	drawMatches(img_1, keyPoints_1, img_2, keyPoints_2,    
		good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),    
		vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);    
	imshow( "Match", img_matches);    
	cvWaitKey();    
	return 0;    
}