argc[] and *argv[]

目录

• char *argv[] and char **argv
• The "Square Detector" program
• The End Of The Code
• The Unknown Word
• Defining a Dynamic Array
• Freeing Dynamic Memory
• Arguments to main
• Pointer This(Introducing const Member Functions)

char *argv[] and char **argv

int main (int argc,char *argv[])
int main (int argc,char **argv)     // argv points to argv[]    ,    argv[] points to char

#include<stdio.h>
#include<string.h>
int main(int argc,char *argv[])//同int main(int argc,char **argv)
{
　　char *str_test = "hello wang";
　　int i,j,len;
　　for(i=0;i<argc;i++)
　　{
　　　　printf("argv%d is %s
",i,argv[i]);
　　　　len = strlen(argv[i]);
　　　　printf("len = %d
",len);
　　　　for(j=0;j<len;j++)
　　　　{
　　　　　　printf("argv%d%d is %c
",i,j,argv[i][j]);
　　　　}
　　}
　　printf("str_test = %s
",str_test);
　　printf("str_test = %c
",str_test[1]);
　　return 0;
}

The result of the program:

The "Square Detector" program

// The "Square Detector" program.
// It loads several images sequentially and tries to find squares in
// each image

#include "opencv2/core/core.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui/highgui.hpp"

#include <iostream>
#include <math.h>
#include <string.h>

using namespace cv;
using namespace std;

static void help)
{
	cout <<
		"
A program using pyramid scaling, Canny, contours, contour simplification and
"
		"memory storage (it's got it all folks) to find
"
		"squares in a list of images pic1-6.pn1g
"
		"Returns sequence of squares detected on the image.
"
		"the sequence is stored in the specified memory storage
"
		"Call:
"
		"./squares
"
		"Using OpenCV version %s
" << CV_VERSION << "
" << endl;
}


int thresh = 50, N = 11;
const char* wndname = "Square Detection Demo";

// helper function:
// finds a cosine of angle between vectors
// from pt0->pt1 and from pt0->pt2
static double angle(Point pt1, Point pt2, Point pt0)
{
	double dx1 = pt1.x - pt0.x;
	double dy1 = pt1.y - pt0.y;
	double dx2 = pt2.x - pt0.x;
	double dy2 = pt2.y - pt0.y;
	return (dx1*dx2 + dy1*dy2) / sqrt((dx1*dx1 + dy1*dy1)*(dx2*dx2 + dy2*dy2) + 1e-10);
}

// returns sequence of squares detected on the image.
// the sequence is stored in the specified memory storage
static void findSquares(const Mat& image, vector<vector<Point> >& squares)
{
	squares.clear();

	Mat pyr, timg, gray0(image.size(), CV_8U), gray;

	// down-scale and upscale the image to filter out the noise
	pyrDown(image, pyr, Size(image.cols / 2, image.rows / 2));
	pyrUp(pyr, timg, image.size());
	vector<vector<Point> > contours;

	// find squares in every color plane of the image
	for (int c = 0; c < 3; c++)
	{
		int ch[] = { c, 0 };
		mixChannels(&timg, 1, &gray0, 1, ch, 1);

		// try several threshold levels
		for (int l = 0; l < N; l++)
		{
			// hack: use Canny instead of zero threshold level.
			// Canny helps to catch squares with gradient shading
			if (l == 0)
			{
				// apply Canny. Take the upper threshold from slider
				// and set the lower to 0 (which forces edges merging)
				Canny(gray0, gray, 0, thresh, 5);
				// dilate canny output to remove potential
				// holes between edge segments
				dilate(gray, gray, Mat(), Point(-1, -1));
			}
			else
			{
				// apply threshold if l!=0:
				//     tgray(x,y) = gray(x,y) < (l+1)*255/N ? 255 : 0
				gray = gray0 >= (l + 1) * 255 / N;
			}

			// find contours and store them all as a list
			findContours(gray, contours, RETR_LIST, CHAIN_APPROX_SIMPLE);

			vector<Point> approx;

			// test each contour
			for (size_t i = 0; i < contours.size(); i++)
			{
				// approximate contour with accuracy proportional
				// to the contour perimeter
				approxPolyDP(Mat(contours[i]), approx, arcLength(Mat(contours[i]), true)*0.02, true);

				// square contours should have 4 vertices after approximation
				// relatively large area (to filter out noisy contours)
				// and be convex.
				// Note: absolute value of an area is used because
				// area may be positive or negative - in accordance with the
				// contour orientation
				if (approx.size() == 4 &&
					fabs(contourArea(Mat(approx))) > 1000 &&
					isContourConvex(Mat(approx)))
				{
					double maxCosine = 0;

					for (int j = 2; j < 5; j++)
					{
						// find the maximum cosine of the angle between joint edges
						double cosine = fabs(angle(approx[j % 4], approx[j - 2], approx[j - 1]));
						maxCosine = MAX(maxCosine, cosine);
					}

					// if cosines of all angles are small
					// (all angles are ~90 degree) then write quandrange
					// vertices to resultant sequence
					if (maxCosine < 0.3)
						squares.push_back(approx);
				}
			}
		}
	}
}


// the function draws all the squares in the image
static void drawSquares(Mat& image, const vector<vector<Point> >& quares)
{
	for (size_t i = 0; i < squares.size(); i++)
	{
		const Point* p = &squares[i][0];
		int n = (int)squares[i].size();
		polylines(image, &p, &n, 1, true, Scalar(0, 255, 0), 3, LINE_AA);
	}

	imshow(wndname, image);
}


int main(int /*argc*/, char** /*argv*/)
{
	static const char* names[] = { "D:/OpenCV 3.1/opencv/sources/samples/data/pic1.png",
		"D:/OpenCV 3.1/opencv/sources/samples/data/pic2.png",
		"D:/OpenCV 3.1/opencv/sources/samples/data/pic3.png",
		"D:/OpenCV 3.1/opencv/sources/samples/data/pic4.png", 
		"D:/OpenCV 3.1/opencv/sources/samples/data/pic5.png", 
		"D:/OpenCV 3.1/opencv/sources/samples/data/pic6.png", 0 };
	help();
	namedWindow(wndname, 1);
	vector<vector<Point> > squares;

	for (int i = 0; names[i] != 0; i++)
	{
		Mat image = imread(names[i], 1);
		if (image.empty())
		{
			cout << "Couldn't load " << names[i] << endl;
			continue;
		}

		findSquares(image, squares);
		drawSquares(image, squares);

		int c = waitKey();
		if ((char)c == 27)
			break;
	}

	return 0;
}

The End Of The Code

The Unknown Word

First Column	Second Column
cosine	余弦
a cosine of angle	角度的余弦值
cast	铸造；投射；投掷[kaest]
Named Casts	命名的强制类型转化
reinterpret	重新解读[ri:in'te:rprit]
grammar	语法['graeme]
the specific kind of the conversion	某种特定的转化
is performed on the expression	在expression上执行
sort	分类[so:rt]

The gerenal form for the named cast notation is the following:

cast-name<type>(expression);

• cast-name may be one of static-cast,const-cast,dynamic-cast,or reinterpret-cast.
• type is the target type of the conversion.
• expression is the value to be cast.
• The type of cast determines the specific kind of conversion that is performed on the expression.

Defining a Dynamic Array

When we dynamically allocate an array,we specify the type and size but do not name the object.Instead,the new expression returns a pointer to the first element in the newly allocated array:

int *pia=new int[10];	//array of 10 uninitialized ints

Freeing Dynamic Memory

delete [] pia;

deallocates the array pointed to by pia,returning the associated memory to the free store.The empty bracket pair between the delete keyword and the pinter is necessary:It indicates to the compiler that the pointer addresses an array of elements on the free store and not simply a single object.

Arguments to main

argument is often novice programmer's first encouter with pointers to arrays of pointers and can prove intimidating.However,it is quite simple to understand.Since argv is used to refer to an array of strings,its declaration will look like this char *argv[]

• int main(int argc,char *argv[]);
• int main(int argc,char **argv);

Pointer This(Introducing const Member Functions)

This is a keyword in C++,and also a const pointer.It points to the current object,and it can access all the members of the current object.For example,for stu.show(),stu is the current object,and this points to stu.

The following is a complete example of using this:

#include <iostream>
using namespace std;
class Student{
public:
    void setname(char *name);
    void setage(int age);
    void setscore(float score);
    void show();
private:
    char *name;
    int age;
    float score;
};

void Student::setname(char *name){
    this->name = name;
}
void Student::setage(int age){
    this->age = age;
}
void Student::setscore(float score){
    this->score = score;
}
void Student::show(){
    cout<<this->name<<"的年龄是"<<this->age<<"，成绩是"<<this->score<<endl;
}

int main(){
    Student *pstu = new Student;
    pstu -> setname("李华");
    pstu -> setage(16);
    pstu -> setscore(96.5);
    pstu -> show();

    return 0;
}

• The Result