C++ do_something函数代码示例

void test() {
  if (cond("if1") /*comment*/) do_something("same-line");

  if (cond("if2"))
    do_something("single-line");
  // CHECK-MESSAGES: :[[@LINE-2]]:19: warning: statement should be inside braces
  // CHECK-FIXES: if (cond("if2")) {
  // CHECK-FIXES: }

  if (cond("if3") /*comment*/)
    // some comment
    do_something("three"
                 "lines");
  // CHECK-MESSAGES: :[[@LINE-4]]:31: warning: statement should be inside braces
  // CHECK-FIXES: if (cond("if3") /*comment*/) {
  // CHECK-FIXES: }

  if (cond("if4") /*comment*/)
    // some comment
    do_something("many"
                 "many"
                 "many"
                 "many"
                 "lines");
  // CHECK-MESSAGES: :[[@LINE-7]]:31: warning: statement should be inside braces
  // CHECK-FIXES: if (cond("if4") /*comment*/) {
  // CHECK-FIXES: }
}

int main(int argc,char *argv[])
{
    int rank, num_of_processes;
    int i;

    MPI_Comm comm = MPI_COMM_WORLD;

    MPI_Init(&argc,&argv);
    MPI_Comm_size( comm, &num_of_processes);
    MPI_Comm_rank( comm, &rank);

    int localsum = 0;
    int globalsum = 0;
    int expectedsum = 0;
    
    if(rank == 0) {
        printf("Checking mpi_scan(sum)... (if you see no output then you are good)\n");
    }

    localsum = do_something(rank, 2);
    globalsum = 0;
    MPI_Scan(&localsum,&globalsum,1,MPI_INT,MPI_SUM,MPI_COMM_WORLD);

    expectedsum = 0;
    // count upto my rank and verify that that was the return from scan
    for(i=0; i<rank+1; i++) {
        expectedsum = expectedsum + do_something(i, 2);
    }
        
    if (globalsum != expectedsum) {
        printf("ERROR: Expected %d got %d [rank:%d]\n", expectedsum, globalsum, rank);
    }
        
    MPI_Finalize();
}

int
test_switch (int i, int j)
{
  int result = 0;			/* count(5) */

  switch (i)				/* count(5) */
    {
      case 1:
        result = do_something (2);	/* count(1) */
        break;
      case 2:
        result = do_something (1024);
        break;
      case 3:
      case 4:
        if (j == 2)			/* count(3) */
          return do_something (4);	/* count(1) */
        result = do_something (8);	/* count(2) */
        break;
      default:
	result = do_something (32);	/* count(1) */
	switch_m++;			/* count(1) */
        break;
    }
  return result;			/* count(4) */
}

int
main(int argc, const char* argv[])
{
    printf("--> main()\n");
    do_something();

    hrt_tstamp t0, t1;
    hrt_tnull(&t0);
    hrt_tnull(&t1);

    printf("\nmarking time...\n");
    int r;
    if ((r = hrt_tnow(&t0)) != 0) {
        fprintf(stderr, "error: hrt_now(&t0) returned %d\n", r);
    }
    hrt_tprint(&t0);

    do_something();

    printf("\nmarking time...\n");
    if ((r = hrt_tnow(&t1)) != 0) {
        fprintf(stderr, "error: hrt_now(&t1) returned %d\n", r);
    }
    hrt_tprint(&t1);

    printf("\namount of times:\n");
    double rtmicros = hrt_rtmicros(&t1.rtstamp, &t0.rtstamp);
    double ctmicros = hrt_ctmicros(&t1.ctstamp, &t0.ctstamp);
    printf("real   = %.3f us\n", rtmicros);
    printf("cpu    = %.3f us\n", ctmicros);
    
    printf("\n<-- main()\n");
    return 0;
}

int
pack_unpack (char *s, char *p)
{
  char *send, *pend;
  char type;
  int integer_size;

  send = s + strlen (s);
  pend = p + strlen (p);

  while (p < pend)
    {
      type = *p++;

      switch (type)
 {
 case 's':
   integer_size = 2;
   goto unpack_integer;

 case 'l':
   integer_size = 4;
   goto unpack_integer;

 unpack_integer:
   switch (integer_size)
     {
     case 2:
       {
  union
  {
    int16_t i;
    char a[sizeof (int16_t)];
  }
  v;
  memcpy (v.a, s, sizeof (int16_t));
  s += sizeof (int16_t);
  do_something (v.i);
       }
       break;

     case 4:
       {
  union
  {
    int32_t i;
    char a[sizeof (int32_t)];
  }
  v;
  memcpy (v.a, s, sizeof (int32_t));
  s += sizeof (int32_t);
  do_something (v.i);
       }
       break;
     }
   break;
 }
    }
  return (int) *s;
}

int
main()
{
  do_something (2);
  do_something (3);
  do_something (5);
  do_something (70);
}

int main () {
    std::function<void(int, int)> lamarck = [&](int a, int b){ std::cout << a << b; };

    auto func = make_function([](){}); // lambda
    auto func2 = make_function(abc); // free function
    auto func3 = make_function(fo_abc()); // function object
    do_something(func);
    do_something(func2);
    do_something(func3);
}

int
test_ifelse3 (int i, int j)
{
  int result = 1;
  if (i > 10 && j > i && j < 20)	/* count(11) */
    result = do_something (16);		/* count(1) */
  if (i > 20)				/* count(11) */
    if (j > i)				/* count(5) */
      if (j < 30)			/* count(2) */
	result = do_something (32);	/* count(1) */
  if (i == 3 || j == 47 || i == j)	/* count(11) */
    result = do_something (64);		/* count(3) */
  return result;			/* count(11) */
}

int main()
{
    do_something(A());
    do_something(A(10));
    
    // this will cause error
//    do_something(20);

    // call explicit conversion
    do_something(static_cast<A>(20));

    // not recommanded
    do_something((A)30);
    return 0;
}

void foo(struct obj1 *op) {
	TESLA_WITHIN(context,
/*
 * TODO: use CHECK-DAG once we switch to LLVM 3.4:
 *
 * First, we need to look up op->child_of_1->child_of_2:
 * CHECK: [[PTR:%[_a-zA-Z0-9\.]+]] = getelementptr inbounds %struct.obj1* %op
 * CHECK: [[C:%[_a-zA-Z0-9\.]+]] = load %struct.obj2** [[PTR]]
 *
 * CHECK: [[PTR:%[_a-zA-Z0-9\.]+]] = getelementptr inbounds %struct.obj2* [[C]]
 * CHECK: [[CHILD:%[_a-zA-Z0-9\.]+]] = load %struct.obj1** [[PTR]]
 *
 * Next, we look up op->child_of_1->value:
 * CHECK: [[PTR:%[_a-zA-Z0-9\.]+]] = getelementptr inbounds %struct.obj1* %op
 * CHECK: [[C:%[_a-zA-Z0-9\.]+]] = load %struct.obj2** [[PTR]]
 *
 * CHECK: [[PTR:%[_a-zA-Z0-9\.]+]] = getelementptr inbounds %struct.obj2* [[C]]
 * CHECK: [[VALUE:%[_a-zA-Z0-9\.]+]] = load i32* [[PTR]]
 *
 * CHECK: call void [[INSTR:@.*_tesla_instr.*assert.*]](%struct.obj1* [[CHILD]], [[INT:i[3264]+]] [[VALUE]])
 */
		eventually(
			do_something(
				op->child_of_1->child_of_2,
				op->child_of_1->value) == 0
		)
	);
}

	void process_data()
	{
		std::unique_lock<std::mutex> lk( get_lock() ); /* (1) */
		do_something();

		std::cout << "owns_lock : " << lk.owns_lock() << std::endl;
	} 

int
test_ifelse2 (int i)
{
  int result = 0;
  if (!i)				/* count(6) */
    result = do_something (1);		/* count(1) */
  if (i == 1)				/* count(6) */
    result = do_something (1024);
  if (i == 2)				/* count(6) */
    result = do_something (2);		/* count(3) */
  if (i == 3)				/* count(6) */
    return do_something (8);		/* count(2) */
  if (i == 4)				/* count(4) */
    return do_something (2048);
  return result;			/* count(4) */
}

void mainPlustHeaderCallAndReturnPlusMain() {
  int i = 0;
  i++;
  do_something(i);
  causeDivByZeroInMain2(i);
  i++;
}

main() 
{
	int s, t;
	if ((s = establish(PORTNUM)) < 0) 
	{													 				/* plug in the phone */
		perror("establish");
		exit(1);
	} 
																		/* how a concurrent server looks like */
	for (;;) 
	{																	/* loop for phone calls */
		if ((t= get_connection(s)) < 0) 
		{																/* get a connection */
			perror("accept"); 											/* bad */
			exit(1);	
		}
		switch( fork() ) 
		{																/* try to handle connection */
			case -1 : 													/* bad news. scream and die */
				perror("fork");
				close(s);
				close(t);
				exit(1);
			case 0 : 													/* we're the child, do something */
				close(s);
				do_something(t);
				close(t);
				exit(0);
			default : 													/* we're the parent so look for */
				close(t); 												/* another connection */
				continue;
		}
	}
}														 				/* end of main */

main(int argc, char* argv[],char ** environ)
{
      int child_proc_number = MAX_CHILD_NUMBER; 
      int i, ch; 
      pid_t  child_pid; 
      pid_t pid[10]={0};
     if (argc > 1)
     {
         child_proc_number = atoi(argv[1]); 
         child_proc_number= (child_proc_number > 10) ? 10 :
                                                    child_proc_number;
     } 
    for (i=0; i<child_proc_number; i++) {
        child_pid=fork();
        switch(child_pid){
          case -1:exit(1);

          case 0:proc_number=i;
                 do_something();
                 exit(1);
          default:pid[i]=child_pid;break;
        
      }
    }
      /* 让用户选择杀死进程，数字表示杀死该进程，q退出 */
   while ((ch = getchar()) != 'q'){ 
        if (isdigit(ch)){
                 kill(pid[ch-'0'],SIGTERM);
                 wait();
        }
   }
   kill(0,SIGTERM);
   return;
}