自学教程：C++ C1函数代码示例

splatclient::splatclient(string windowstyle,nCursesWindow *window, string ip, unsigned int port){    //SSL stuff    SSL_library_init();    ERR_load_crypto_strings();    ERR_load_SSL_strings();    OpenSSL_add_all_algorithms();//	init receive buffer    recv_buff.iMessageid=recv_buff.tSize=0;    memset(&(recv_buff.cMesg), '/0',CHUNK);    sessionID=0;    win=window;    sockfd=-1;    log= new cLogfile("splatclient.log",false);    msgID=0;    server_ip=ip;    server_port=port;//	vParseWindowstyle(windowstyle, window);    if (!win)    {        sLogelement C1(-1, "Keine Windowfunktion übergeben", false);        (*log)<<C1;        exit(1);    }    sLogelement C1(0, "Splatclient erschaffen", true);    (*log)<<C1;    *win<<C1;    if (!bConnect(port, ip))    {        win->windowstack.back()->nCgetwin().~nCursesWindow();        exit(1);    }    else    {        sLogelement C1(-1, "Verbindung hergestellt", true);        *win<<C1;    }    keypad(stdscr,true);    nodelay(win->windowstack.back()->win, true);    if (!iGetsocket())    {        sLogelement t1(-1,"No socket found!",false);//FATAL        *win<<t1;        win->windowstack.back()->nCgetwin().~nCursesWindow();        (*log) << t1;        exit(1);    }    //cFlow_client    bkgactive=true; //still need to be active for ping/pong messages    //MENU    menu=NULL;    vCreateMenu();    bDirty=true;}

void foo(int coin) {  C1 c1 = coin ? C1(1) : C1(2);  if (coin) {    clang_analyzer_eval(c1.getX() == 1); // expected-warning{{TRUE}}  } else {    clang_analyzer_eval(c1.getX() == 2); // expected-warning{{TRUE}}  }  C2 c2 = coin ? C2(3, 4) : C2(5, 6);  if (coin) {    clang_analyzer_eval(c2.getX() == 3); // expected-warning{{TRUE}}    clang_analyzer_eval(c2.getY() == 4); // expected-warning{{TRUE}}  } else {    clang_analyzer_eval(c2.getX() == 5); // expected-warning{{TRUE}}    clang_analyzer_eval(c2.getY() == 6); // expected-warning{{TRUE}}  }}

int main(){    C0().f0();        C1().f0();    C1().f1();        C2().f0();    C2().f1();    C2().f2();        C3().f0();    C3().f1();    C3().f2();    C3().f3();}

int test_vector_add(){	// Blog: http://blog.csdn.net/fengbingchun/article/details/74120057	// Vector addition: C = A + B, implements element by element vector addition	const int numElements{ 50000 };	std::vector<float> A(numElements), B(numElements), C1(numElements), C2(numElements);	// Initialize vector	for (int i = 0; i < numElements; ++i) {		A[i] = rand() / (float)RAND_MAX;		B[i] = rand() / (float)RAND_MAX;	}	float elapsed_time1{ 0.f }, elapsed_time2{ 0.f }; // milliseconds	int ret = vector_add_cpu(A.data(), B.data(), C1.data(), numElements, &elapsed_time1);	if (ret != 0) PRINT_ERROR_INFO(vectorAdd_cpu);	ret = vector_add_gpu(A.data(), B.data(), C2.data(), numElements, &elapsed_time2);	if (ret != 0) PRINT_ERROR_INFO(vectorAdd_gpu);	for (int i = 0; i < numElements; ++i) {		if (fabs(C1[i] - C2[i]) > EPS_) {			fprintf(stderr, "Result verification failed at element %d!/n", i);			return -1;		}	}	fprintf(stderr, "cpu run time: %f ms, gpu run time: %f ms/n", elapsed_time1, elapsed_time2);	return 0;}

int test_long_vector_add(){	// Blog: http://blog.csdn.net/fengbingchun/article/details/75570546	const int length{ 100000000 };	std::unique_ptr<float[]> A(new float[length]);	std::unique_ptr<float[]> B(new float[length]);	std::unique_ptr<float[]> C1(new float[length]);	std::unique_ptr<float[]> C2(new float[length]);	generator_random_number(A.get(), length, -1000.f, 1000.f);	generator_random_number(B.get(), length, -1000.f, 1000.f);	float elapsed_time1{ 0.f }, elapsed_time2{ 0.f }; // milliseconds	int ret = long_vector_add_cpu(A.get(), B.get(), C1.get(), length, &elapsed_time1);	if (ret != 0) PRINT_ERROR_INFO(long_vector_add_cpu);	ret = long_vector_add_gpu(A.get(), B.get(), C2.get(), length, &elapsed_time2);	if (ret != 0) PRINT_ERROR_INFO(matrix_mul_gpu);	int count_error{ 0 };	for (int i = 0; i < length; ++i) {		if (count_error > 100) return -1;		if (fabs(C1[i] - C2[i]) > EPS_) {			fprintf(stderr, "Result verification failed at element %d, C1: %f, C2: %f/n",				i, C1[i], C2[i]);			++count_error;		}	}	fprintf(stderr, "cpu run time: %f ms, gpu run time: %f ms/n", elapsed_time1, elapsed_time2);	return 0;}

//--------------------------------------------------------------void ofApp::setup(){    ofSetFrameRate(60.0f);  for(int i=0;i<12;i++)  {    randColorDrop();  }  Attractor.reset(new ColorDropAttractor());  Merger.reset(new ColorDropMerger());  Dragger.reset(new ColorDropDragger());    ofPtr<ColorHole> H;  ofFloatColor C0(ofFloatColor::yellow);  C0.setBrightness(0.7f);  H.reset(new ColorHole(    ofVec2f(200,200),    C0,2600));  Holes.push_back(H);  ofFloatColor C1(ofFloatColor::cyan);  C1.setBrightness(0.7f);  H.reset(new ColorHole(    ofVec2f(750,240),    ofFloatColor(0.8f,0.0f,0.8f,1),3000));  Holes.push_back(H);  ofFloatColor C2(ofFloatColor::violet);  C2.setBrightness(0.7f);  H.reset(new ColorHole(    ofVec2f(450,500),    ofFloatColor(0.0f,0.9f,0.9f,1),3800));  Holes.push_back(H);}

int test_matrix_mul(){	// Blog: http://blog.csdn.net/fengbingchun/article/details/76618165	// Matrix multiplication: C = A * B	// 矩阵A、B的宽、高应是32的整数倍	const int rowsA{ 352 }, colsA{ 672 }, rowsB = colsA, colsB{ 384 };	std::unique_ptr<float[]> A(new float[colsA*rowsA]);	std::unique_ptr<float[]> B(new float[colsB*rowsB]);	std::unique_ptr<float[]> C1(new float[rowsA*colsB]);	std::unique_ptr<float[]> C2(new float[rowsA*colsB]);	generator_random_number(A.get(), colsA*rowsA, -1.f, 1.f);	generator_random_number(B.get(), colsB*rowsB, -1.f, 1.f);	float elapsed_time1{ 0.f }, elapsed_time2{ 0.f }; // milliseconds	int ret = matrix_mul_cpu(A.get(), B.get(), C1.get(), colsA, rowsA, colsB, rowsB, &elapsed_time1);	if (ret != 0) PRINT_ERROR_INFO(matrix_mul_cpu);	ret = matrix_mul_gpu(A.get(), B.get(), C2.get(), colsA, rowsA, colsB, rowsB, &elapsed_time2);	if (ret != 0) PRINT_ERROR_INFO(matrix_mul_gpu);	int count{ 0 };	for (int i = 0; i < rowsA*colsB; ++i) {		if (count > 100) return -1;		if (fabs(C1[i] - C2[i]) > EPS_) {			fprintf(stderr, "Result verification failed at element %d, C1: %f, C2: %f/n",				i, C1[i], C2[i]);			++count;		}	}	fprintf(stderr, "test matrix mul: cpu run time: %f ms, gpu run time: %f ms/n", elapsed_time1, elapsed_time2);	return 0;}

void graphics::NgoiLang(QPainter& painter,int x,int y,int c,int r){    QPoint A(x-r/2,y+c);    QPoint B(x+r/2,y+c);    QPoint C(x+r/2,y+c/3);    QPoint D(x,y);    QPoint E(x-r/2,y+c/3);    QPolygon poly1;    poly1 << D << E << A << B << C;    painter.drawPolygon(poly1);// ve cai cua    QPoint A1(x,y+c);    QPoint B1(x,y+2*c/3);    QPoint C1(x-r/4,y+2*c/3);    QPoint D1(x-r/4,y+c);    QPolygon poly2;    poly2 << A1 << B1 << C1 << D1;    painter.drawPolyline(poly2); // ve cua so   QPoint A11(x-r/4,y+c/6);    QPoint B11(x-r/4,y);   QPoint C11(x-r/8,y);    QPoint D11(x-r/8,y+c/12);   QPolygon poly21;    poly21 << A11 << B11 << C11 << D11;    painter.drawPolygon(poly21);    painter.drawRect(x+r/4,y+c/2.5,c/10,r/10);}

void ViewmdaModel::setC1(int i) {	if (m_d1<0) return;	if (C1()==i) return;	if ((i<0)||(i>=N1())) return;	m_current_index[m_d1]=i;	emit currentIndexChanged();	} 

int sc_main (int argc , char *argv[]) {#ifdef KASCPAR 	veri_signal<bool> s1; 	veri_signal<bool> s2; 	veri_signal<bool> s3;#else	sc_core::sc_signal<bool> s1("s1"), s2("s2");//, s3("s3");#endif 	Component C1("C1"); 	Component C2("C2");// 	Component C3("C3");       // 	//	superclass* C;// 	//	C = dynamic_cast<superclass*>(&C3);// 	//	superclass* S = C;// 	//	Component* res = dynamic_cast<Component*>(S); 	C1.out(s1); 	C2.out(s2);// 	//	(*res).out(s3);// 	C3.out(s3); 	C1.in(s2); 	C2.in(s1);// 	C3.in(s2);// 	C1.isHead = true;	//Run the Simulation for "200 nanosecnds"	sc_start(200, SC_NS);	return 0;}

int main(int argc, char** argv){	irqSet(IRQ_VBLANK, &vblank);	#ifdef TEXTMODE		videoSetMode(MODE_0_2D);		videoSetModeSub(MODE_0_2D);		vramSetBankA(VRAM_A_MAIN_BG);		vramSetBankC(VRAM_C_SUB_BG);	#endif//TEXTMODE	Display::init();	keysSetRepeat(30, 12);	srand(time(NULL));	Player P1(FGrave);	Player P2(FMidori);	ControlLocal	C1(P1);	ControlAI		C2(P2);	//DisplayPlayerOverview a(0, 0, 0, 32, 1, P1);	//DisplayContainer b(0, 0, 1, 32, 21, P1.hand());	//DisplayCard c(1, 0, 0, 32, 24, P1.hand().at(0), false);	Game(&C1, &C2);	while(1){		update();	}	return 0;}

// Run a single benchmark for multiplying m x k x n with num_steps of recursion.// To just call GEMM, set num_steps to zero.// The median of five trials is printed to std::cout.// If run_check is true, then it alsovoid SingleBenchmark(int m, int k, int n, int num_steps, int algorithm) {  // Run a set number of trials and pick the median time.  int num_trials = 1;  std::vector<double> times(num_trials);  for (int trial = 0; trial < num_trials; ++trial) {    Matrix<double> A = RandomMatrix<double>(m, k);    Matrix<double> B = RandomMatrix<double>(k, n);    Matrix<double> C1(m, n);    if (algorithm == SMIRNOV54) {      times[trial] = square54_1::FastMatmul(A, B, C1, 3);    } else if (algorithm == MKL) {      times[trial] = strassen::FastMatmul(A, B, C1, 0);    } else if (algorithm == STRASSEN) {      times[trial] = strassen::FastMatmul(A, B, C1, num_steps);    } else if (algorithm == SCHONHAGE333_21_117_APPROX) {      times[trial] = schonhage333_21_117_approx::FastMatmul(A, B, C1, num_steps);    }  }  // Spit out the median time  std::sort(times.begin(), times.end());  size_t ind = num_trials / 2;  std::cout << " " << m << " " << k << " " << n << " "            << num_steps << " " << times[ind] << " "            << "; ";}

int test_streams(){	// Blog: http://blog.csdn.net/fengbingchun/article/details/76532198	const int length{ 1024 * 1024 * 20};	std::unique_ptr<int[]> A(new int[length]);	std::unique_ptr<int[]> B(new int[length]);	std::unique_ptr<int[]> C1(new int[length]);	std::unique_ptr<int[]> C2(new int[length]);	generator_random_number<int>(A.get(), length, -100, 100);	generator_random_number<int>(B.get(), length, -100, 100);	std::for_each(C1.get(), C1.get() + length, [](int& n) {n = 0; });	std::for_each(C2.get(), C2.get() + length, [](int& n) {n = 0; });	float elapsed_time1{ 0.f }, elapsed_time2{ 0.f }; // milliseconds	int ret = streams_cpu(A.get(), B.get(), C1.get(), length, &elapsed_time1);	if (ret != 0) PRINT_ERROR_INFO(streams_cpu);	ret = streams_gpu(A.get(), B.get(), C2.get(), length, &elapsed_time2);	if (ret != 0) PRINT_ERROR_INFO(streams_gpu);	for (int i = 0; i < length; ++i) {		if (C1[i] != C2[i]) {			fprintf(stderr, "their values are different at: %d, val1: %d, val2: %d/n",				i, C1[i], C2[i]);			return -1;		}	}	fprintf(stderr, "test streams' usage: cpu run time: %f ms, gpu run time: %f ms/n", elapsed_time1, elapsed_time2);	return 0;}

bool intersectsRect(Vector2 A, Vector2 B, double x, double y, double width, double height) {    Vector2 C0(x, y);    Vector2 D0(x + width, y);    Vector2 C1(x + width, y);    Vector2 D1(x + width, y + height);    Vector2 C2(x + width, y + height);    Vector2 D2(x, y + height);    Vector2 C3(x, y + height);    Vector2 D3(x, y);    bool I0, I1, I2, I3;    Vector2 buf;    I0 = intersects(A, B, C0, D0, buf);    I1 = intersects(A, B, C1, D1, buf);    I2 = intersects(A, B, C2, D2, buf);    I3 = intersects(A, B, C3, D3, buf);    if(I0 || I1 || I2 || I3) {        return false;    }    return true;}

void	inter_sphere(t_caster *caster, t_object *sphere){  double	delt;  double	a;  double	b;  double	c;  init_temp_pos(caster, sphere);  a = A1(caster->temp_vec.x, caster->temp_vec.y, caster->temp_vec.z);  b = B1(caster->temp_vec.x, caster->temp_pos.x, caster->temp_vec.y,	 caster->temp_pos.y, caster->temp_vec.z, caster->temp_pos.z);  c = C1(sphere->data.radius, caster->temp_pos.x, caster->temp_pos.y	 , caster->temp_pos.z);  delt = (pow(b, 2.0) - 4.0 * (a * c));  if (delt >= 0.0)    {      sphere->dist = get_nearest((- b - sqrt(delt)) / (2.0 * a),				 (- b + sqrt(delt)) / (2.0 * a));      if (sphere->dist > 0.0 && sphere->dist < caster->intersection.dist)	{	  caster->intersection.brightness = sphere->brightness;	  init_intersection(caster, sphere);	  rotate_caster(caster, sphere);	}    }}

double SpinAdapted::StackCreCreDesDes::redMatrixElement(Csf c1, vector<Csf>& ladder, const StackSpinBlock* b){  assert( build_pattern == "(((CC)(D))(D))" );  double element = 0.0;  int I = get_orbs()[0];   int J = get_orbs()[1];  int K = get_orbs()[2];  int L = get_orbs()[3];  int Slaterlength = c1.det_rep.begin()->first.size();  vector<bool> backupSlater1(Slaterlength,0), backupSlater2(Slaterlength,0);  // Must take into account how the 4-index is built from a combination of the 2-index ops  std::vector<SpinQuantum> quantum_ladder = get_quantum_ladder().at("(((CC)(D))(D))");  assert( quantum_ladder.size() == 3 );  SpinQuantum deltaQuantum12 = quantum_ladder.at(0);  SpinQuantum deltaQuantum123 = quantum_ladder.at(1);  SpinQuantum deltaQuantum1234 = quantum_ladder.at(2);//FIXME components != 0  deltaQuantum[0] = deltaQuantum1234;  // Spin quantum data for CC  IrrepSpace sym12 = deltaQuantum12.get_symm();  int irrep12 = deltaQuantum12.get_symm().getirrep();  int spin12 = deltaQuantum12.get_s().getirrep();  // Spin quantum data for (CC)D  IrrepSpace sym123 = deltaQuantum123.get_symm();  int irrep123 = deltaQuantum123.get_symm().getirrep();  int spin123= deltaQuantum123.get_s().getirrep();  // Spin quantum data for total operator  IrrepSpace sym1234 = deltaQuantum1234.get_symm();  int irrep1234 = deltaQuantum1234.get_symm().getirrep();  int spin1234 = deltaQuantum1234.get_s().getirrep();  TensorOp C1(I, 1);   TensorOp C2(J, 1);   TensorOp D3(K,-1);   TensorOp D4(L,-1);   TensorOp CC = C1.product(C2, spin12, irrep12);  TensorOp CCD = CC.product(D3, spin123, irrep123);  TensorOp CCDD = CCD.product(D4, spin1234, irrep1234);//FIXME loop over deltaQuantum components  int j = 0;  for (int i=0; i<ladder.size(); i++)  {    int index = 0; double cleb=0.0;    if (nonZeroTensorComponent(c1, deltaQuantum[j], ladder[i], index, cleb)) {      std::vector<double> MatElements = calcMatrixElements(c1, CCDD, ladder[i], backupSlater1, backupSlater2) ;      element = MatElements[index]/cleb;      break;    }    else      continue;  }  return element;}

	bool collision(const CircleHitBox &cercleBox1, const CircleHitBox &cercleBox2)	{		sf::Vector2f C1(cercleBox1.p), C2(cercleBox2.p);		float d2 = (C1.x-C2.x)*(C1.x-C2.x) + (C1.y-C2.y)*(C1.y-C2.y);		if (d2 > (cercleBox1.rayon + cercleBox2.rayon)*(cercleBox1.rayon + cercleBox2.rayon))			return false;		else			return true;	}

 virtual void compute(const vd::Time& t) {     f2 = DSAT() * C2();     f1 = C1() * p1;     grad(C3) = (f2);     grad(C1) = 0 - (f1);     grad(DSAT) = 0;     grad(C2) = (f1) - (f2); }

void RatioNSDistanceTransform::processRow(const BinaryPixelType *imageRow) {    int col;#define N1_SETMINUS_N2_COUNT  1#define N2_SETMINUS_N1_COUNT  5#define N1_CAP_N2_COUNT 3    static vect n1[N1_SETMINUS_N2_COUNT]   = {{-1, 1}};    static vect n2[N2_SETMINUS_N1_COUNT]   = {{1, 0}, {2, 0}, {2, 1}, {1, 2}, {2, 2}};    static vect n12[N1_CAP_N2_COUNT] = {{0, 1}, {1, 1}, {0, 2}};    for (col = 0; col < _cols; col++) {	if (imageRow[col] == 0)	    dtLines[0][col + 2] = 0;	else {	    GrayscalePixelType val;	    GrayscalePixelType dt;	    int k;	    val = GRAYSCALE_MAX;	    for (k = 0; k < N1_SETMINUS_N2_COUNT; k++) {		assert(n1[k].y >= 0);		assert(n1[k].y <= 2);		assert(col + 2 - n1[k].x >= 0);		assert(col + 2 - n1[k].x < _cols + 3);		val = std::min(val, dtLines[n1[k].y][col + 2 - n1[k].x]);	    }	    assert(C1(d.num, d.den, (int) val) == d.mbf1i(d.mbf1(val)+1)+1);	    dt = std::min((int)_dMax, d.mbf1i(d.mbf1(val)+1)+1);	    val = GRAYSCALE_MAX;	    for (k = 0; k < N2_SETMINUS_N1_COUNT; k++) {		assert(n2[k].y >= 0);		assert(n2[k].y <= 2);		assert(col + 2 - n2[k].x >= 0);		assert(col + 2 - n2[k].x < _cols + 3);		val = std::min(val, dtLines[n2[k].y][col + 2 - n2[k].x]);	    }	    assert(C2(d.num, d.den, (int) val) == d.mbf2i(d.mbf2(val)+1)+1);	    dt = std::min((int) dt, d.mbf2i(d.mbf2(val)+1)+1);	    val = GRAYSCALE_MAX;	    for (k = 0; k < N1_CAP_N2_COUNT; k++) {		assert(n12[k].y >= 0);		assert(n12[k].y <= 2);		assert(col + 2 - n12[k].x >= 0);		assert(col + 2 - n12[k].x < _cols + 3);		val = std::min(val, dtLines[n12[k].y][col + 2 - n12[k].x]);	    }	    dt = std::min((int) dt, val + 1);	    dtLines[0][col + 2] = dt;	}    }    _consumer->processRow(dtLines[0]+2);    rotate();}

int test_string_cast_vector(){	int Error = 0;		glm::vec2 A1(1, 2);	std::string A2 = glm::to_string(A1);	Error += A2 != std::string("fvec2(1.000000, 2.000000)") ? 1 : 0;		glm::vec3 B1(1, 2, 3);	std::string B2 = glm::to_string(B1);	Error += B2 != std::string("fvec3(1.000000, 2.000000, 3.000000)") ? 1 : 0;	glm::vec4 C1(1, 2, 3, 4);	std::string C2 = glm::to_string(C1);	Error += C2 != std::string("fvec4(1.000000, 2.000000, 3.000000, 4.000000)") ? 1 : 0;		glm::ivec2 D1(1, 2);	std::string D2 = glm::to_string(D1);	Error += D2 != std::string("ivec2(1, 2)") ? 1 : 0;		glm::ivec3 E1(1, 2, 3);	std::string E2 = glm::to_string(E1);	Error += E2 != std::string("ivec3(1, 2, 3)") ? 1 : 0;		glm::ivec4 F1(1, 2, 3, 4);	std::string F2 = glm::to_string(F1);	Error += F2 != std::string("ivec4(1, 2, 3, 4)") ? 1 : 0;		glm::hvec2 G1(1, 2);	std::string G2 = glm::to_string(G1);	Error += G2 != std::string("hvec2(1.0000, 2.0000)") ? 1 : 0;		glm::hvec3 H1(1, 2, 3);	std::string H2 = glm::to_string(H1);	Error += H2 != std::string("hvec3(1.0000, 2.0000, 3.0000)") ? 1 : 0;		glm::hvec4 I1(1, 2, 3, 4);	std::string I2 = glm::to_string(I1);	Error += I2 != std::string("hvec4(1.0000, 2.0000, 3.0000, 4.0000)") ? 1 : 0;		glm::dvec2 J1(1, 2);	std::string J2 = glm::to_string(J1);	Error += J2 != std::string("dvec2(1.000000, 2.000000)") ? 1 : 0;		glm::dvec3 K1(1, 2, 3);	std::string K2 = glm::to_string(K1);	Error += K2 != std::string("dvec3(1.000000, 2.000000, 3.000000)") ? 1 : 0;		glm::dvec4 L1(1, 2, 3, 4);	std::string L2 = glm::to_string(L1);	Error += L2 != std::string("dvec4(1.000000, 2.000000, 3.000000, 4.000000)") ? 1 : 0;		return Error;}

double SpinAdapted::CreCreCreCre::redMatrixElement(Csf c1, vector<Csf>& ladder, const SpinBlock* b){  assert( build_pattern == "(((CC)(C))(C))" );  double element = 0.0;  int I = get_orbs()[0];   int J = get_orbs()[1];  int K = get_orbs()[2];  int L = get_orbs()[3];  // Must take into account how the 4-index is built from a combination of the 2-index ops  std::vector<SpinQuantum> quantum_ladder = get_quantum_ladder().at("(((CC)(C))(C))");  assert( quantum_ladder.size() == 3 );  SpinQuantum deltaQuantum12 = quantum_ladder.at(0);  SpinQuantum deltaQuantum123 = quantum_ladder.at(1);  SpinQuantum deltaQuantum1234 = quantum_ladder.at(2);  deltaQuantum[0] = deltaQuantum1234;  // Spin quantum data for CC  IrrepSpace sym12 = deltaQuantum12.get_symm();  int irrep12 = deltaQuantum12.get_symm().getirrep();  int spin12 = deltaQuantum12.get_s().getirrep();  // Spin quantum data for (CC)C  IrrepSpace sym123 = deltaQuantum123.get_symm();  int irrep123 = deltaQuantum123.get_symm().getirrep();  int spin123= deltaQuantum123.get_s().getirrep();  // Spin quantum data for total operator  IrrepSpace sym1234 = deltaQuantum1234.get_symm();  int irrep1234 = deltaQuantum1234.get_symm().getirrep();  int spin1234 = deltaQuantum1234.get_s().getirrep();  TensorOp C1(I, 1);   TensorOp C2(J, 1);   TensorOp C3(K, 1);   TensorOp C4(L, 1);   TensorOp CC = C1.product(C2, spin12, irrep12);  TensorOp CCC = CC.product(C3, spin123, irrep123);  TensorOp CCCC = CCC.product(C4, spin1234, irrep1234);  for (int i=0; i<ladder.size(); i++)  {    int index = 0; double cleb=0.0;    if (nonZeroTensorComponent(c1, deltaQuantum[0], ladder[i], index, cleb)) {      std::vector<double> MatElements = calcMatrixElements(c1, CCCC, ladder[i]) ;      element = MatElements[index]/cleb;      break;    }    else      continue;  }  return element;}

 void testConstructor2() {   MRR stdfRec;   stdfRec["DISP_COD"]=C1('M');   TS_ASSERT_EQUALS(stdfRec.storage(), 7u);   std::vector<std::basic_string<char> > str;   stdfRec.to_string(str);   TS_ASSERT_EQUALS(str[0], "7");   TS_ASSERT_EQUALS(str[1], "1");   TS_ASSERT_EQUALS(str[2], "20");   TS_ASSERT_EQUALS(str[3], "0");   TS_ASSERT_EQUALS(str[4], "M"); }

Molecule C2H4(){    int nAtoms = 6;    Eigen::Vector3d C1(0.0000000000,  0.0000000000,  1.2578920000);    Eigen::Vector3d H1(0.0000000000,  1.7454620000,  2.3427160000);    Eigen::Vector3d H2(0.0000000000, -1.7454620000,  2.3427160000);    Eigen::Vector3d C2(0.0000000000,  0.0000000000, -1.2578920000);    Eigen::Vector3d H3(0.0000000000,  1.7454620000, -2.3427160000);    Eigen::Vector3d H4(0.0000000000, -1.7454620000, -2.3427160000);    Eigen::MatrixXd geom(3, nAtoms);    geom.col(0) = C1.transpose();    geom.col(1) = H1.transpose();    geom.col(2) = H2.transpose();    geom.col(3) = C2.transpose();    geom.col(4) = H3.transpose();    geom.col(5) = H4.transpose();    Eigen::VectorXd charges(6), masses(6);    charges << 6.0, 1.0, 1.0, 6.0, 1.0, 1.0;    masses  << 12.00, 1.0078250, 1.0078250, 12.0, 1.0078250, 1.0078250;    double radiusC = (1.70 * 1.20) / convertBohrToAngstrom;    double radiusH = (1.20 * 1.20) / convertBohrToAngstrom;    std::vector<Atom> atoms;    atoms.push_back( Atom("Carbon",   "C", charges(0), masses(0), radiusC, C1, 1.0) );    atoms.push_back( Atom("Hydrogen", "H", charges(1), masses(1), radiusH, H1, 1.0) );    atoms.push_back( Atom("Hydrogen", "H", charges(2), masses(2), radiusH, H2, 1.0) );    atoms.push_back( Atom("Carbon",   "C", charges(3), masses(3), radiusC, C2, 1.0) );    atoms.push_back( Atom("Hydrogen", "H", charges(4), masses(4), radiusH, H3, 1.0) );    atoms.push_back( Atom("Hydrogen", "H", charges(5), masses(5), radiusH, H4, 1.0) );    std::vector<Sphere> spheres;    Sphere sph1(C1, radiusC);    Sphere sph2(H1, radiusH);    Sphere sph3(H2, radiusH);    Sphere sph4(C2, radiusC);    Sphere sph5(H3, radiusH);    Sphere sph6(H4, radiusH);    spheres.push_back(sph1);    spheres.push_back(sph2);    spheres.push_back(sph3);    spheres.push_back(sph4);    spheres.push_back(sph5);    spheres.push_back(sph6);    // D2h as generated by Oxy, Oxz, Oyz    Symmetry pGroup = buildGroup(3, 4, 2, 1);    return Molecule(nAtoms, charges, masses, geom, atoms, spheres, pGroup);};

BOOL CARIB8CharDecode::Analyze( const BYTE* pbSrc, DWORD dwSrcSize, DWORD* pdwReadSize ){	if( pbSrc == NULL || dwSrcSize == 0 || pdwReadSize == NULL){		return FALSE;	}	BOOL bRet = TRUE;	DWORD dwReadSize = 0;	while( dwReadSize < dwSrcSize ){		DWORD dwReadBuff = 0;		//1バイト目チェック		if( pbSrc[dwReadSize] <= 0x20 ){			//C0制御コ
C++ C2函数代码示例
C++ C函数代码示例