Do you know how strlen implemented?

yes, but why first read get me a currect length ?

It remembers it's length

What is html

What is html

its the best language to Hack NASA

hey, i get string object from function

Try with *x=strcpy(...)

I'm interested in learning Android OS, what should i need to learn before learning it?

string::c_str - C++ Reference http://www.cplusplus.com/reference/string/string/c_str/

hi! i have a problem, when making a recursive call and passing Point pt the value of pt doesn't change even though i call method foo (adjustedpoint(start, dir)) - demanding it to change over iterations

hi! i have a problem, when making a recursive call and passing Point pt the value of pt doesn't change even though i call method foo (adjustedpoint(start, dir)) - demanding it to change over iterations

[Error] swiftnav/constants.h: No such file or directory compilation terminated.

#include <math.h> #include <swiftnav/constants.h> #include <swiftnav/coord_system.h> #include <swiftnav/float_equality.h> #include <swiftnav/linear_algebra.h> #include <swiftnav/logging.h> void llhrad2deg(const double llh_rad[3], double llh_deg[3]) { llh_deg[0] = llh_rad[0] * R2D; llh_deg[1] = llh_rad[1] * R2D; llh_deg[2] = llh_rad[2]; } void llhdeg2rad(const double llh_deg[3], double llh_rad[3]) { llh_rad[0] = llh_deg[0] * D2R; llh_rad[1] = llh_deg[1] * D2R; llh_rad[2] = llh_deg[2]; } void wgsllh2ecef(const double llh[3], double ecef[3]) { double d = WGS84_E * sin(llh[0]); double N = WGS84_A / sqrt(1. - d * d); ecef[0] = (N + llh[2]) * cos(llh[0]) * cos(llh[1]); ecef[1] = (N + llh[2]) * cos(llh[0]) * sin(llh[1]); ecef[2] = ((1 - WGS84_E * WGS84_E) * N + llh[2]) * sin(llh[0]); } void wgsecef2llh(const double ecef[3], double llh[3]) { /* Distance from polar axis. */ const double p = sqrt(ecef[0] * ecef[0] + ecef[1] * ecef[1]); /* Compute longitude first, this can be done exactly. */ if (!double_equal(p, 0)) { llh[1] = atan2(ecef[1], ecef[0]); } else { llh[1] = 0; } if (p < WGS84_A * 1e-16) { llh[0] = copysign(M_PI_2, ecef[2]); llh[2] = fabs(ecef[2]) - WGS84_B; return; } /* Caluclate some other constants as defined in the Fukushima paper. */ const double P = p / WGS84_A; const double e_c = sqrt(1. - WGS84_E * WGS84_E); const double Z = fabs(ecef[2]) * e_c / WGS84_A; /* Initial values for S and C correspond to a zero height solution. */ double S = Z; double C = e_c * P; /* Neither S nor C can be negative on the first iteration so * starting prev = -1 will not cause and early exit. */ double prev_C = -1; double prev_S = -1; double A_n, B_n, D_n, F_n; /* Iterate a maximum of 10 times. This should be way more than enough for all * sane inputs */ for (int i = 0; i < 10; i++) { /* Calculate some intermediate variables used in the update step based on * the current state. */ A_n = sqrt(S * S + C * C); D_n = Z * A_n * A_n * A_n + WGS84_E * WGS84_E * S * S * S; F_n = P * A_n * A_n * A_n - WGS84_E * WGS84_E * C * C * C; B_n = 1.5 * WGS84_E * S * C * C * (A_n * (P * S - Z * C) - WGS84_E * S * C); /* Update step. */ S = D_n * F_n - B_n * S; C = F_n * F_n - B_n * C; if (S > C) { C = C / S; S = 1; } else { S = S / C; C = 1; } /* Check for convergence and exit early if we have converged. */ if (fabs(S - prev_S) < 1e-16 && fabs(C - prev_C) < 1e-16) { break; } prev_S = S; prev_C = C; } A_n = sqrt(S * S + C * C); llh[0] = copysign(1.0, ecef[2]) * atan(S / (e_c * C)); llh[2] = (p * e_c * C + fabs(ecef[2]) * S - WGS84_A * e_c * A_n) / sqrt(e_c * e_c * C * C + S * S); }

Share your code through one of these links: • https://linkode.org • https://dpaste.org • https://pastebin.com • https://hastebin.com

For what

For what

Is it okay to overuse lambdas? There is a code I met in https://lefticus.gitbooks.io/cpp-best-practices/content/08-Considering_Performance.html It suggests: // Bad Idea std::string somevalue; if (caseA) { somevalue = "Value A"; } else if(caseB) { somevalue = "Value B"; } else { somevalue = "Value C"; } ——- // Better Idea const std::string somevalue = [&](){ if (caseA) { return "Value A"; } else if (caseB) { return "Value B"; } else { return "Value C"; } }();

Second one is just slightly better

even in performance term? why?

That is because it will be initialized in place

Is it okay to overuse lambdas? There is a code I met in https://lefticus.gitbooks.io/cpp-best-practices/content/08-Considering_Performance.html It suggests: // Bad Idea std::string somevalue; if (caseA) { somevalue = "Value A"; } else if(caseB) { somevalue = "Value B"; } else { somevalue = "Value C"; } ——- // Better Idea const std::string somevalue = [&](){ if (caseA) { return "Value A"; } else if (caseB) { return "Value B"; } else { return "Value C"; } }();

you can check it yourself, the difference is pretty significant unless I made some mistake and they are not doing the same thing. https://quick-bench.com/q/yi3M9lFARrPR8M-Al7VBIdWCMDo

Get ide

What is dynamic memory allocation

some kind of computer magic

What is dynamic memory allocation

What is dynamic memory allocation

#include <stdio.h> #define RUN int str_len(char *); // Calculating the length of String through Pointer. char *str_reverse(char *); // Reversing a String through Pointer. #ifdef RUN int main() { char *str = "Computer"; printf("Length of the String is: %d\n", str_len(str)); printf("Reversed String is: %s\n", str_reverse(str)); return 0; } int str_len(char *ptr) { int i; for (i=0; *(ptr+i)!='\0'; i++); return i; } char *str_reverse(char *ptr) { int len; printf("%d", len); for (len=0; *(ptr + len) != '\0'; len++); for (int i = 0; i < len/2; i++) { // Swapping char temp = *(ptr+i); *(ptr+i) = *(ptr+len-1-i); *(ptr+len-1-i) = temp; } return (ptr); } #endif // RUN

You then store that pointer in a pointer variable myclass* and dereference it to use it

Then there's the heap, where all dynamic allocations are made Whenever you use new you're creating an object in the heap, dynamically allocating (allocating while the program is running) and receiving back a pointer to it

#include <stdio.h> #define RUN int str_len(char *); // Calculating the length of String through Pointer. char *str_reverse(char *); // Reversing a String through Pointer. #ifdef RUN int main() { char *str = "Computer"; printf("Length of the String is: %d\n", str_len(str)); printf("Reversed String is: %s\n", str_reverse(str)); return 0; } int str_len(char *ptr) { int i; for (i=0; *(ptr+i)!='\0'; i++); return i; } char *str_reverse(char *ptr) { int len; printf("%d", len); for (len=0; *(ptr + len) != '\0'; len++); for (int i = 0; i < len/2; i++) { // Swapping char temp = *(ptr+i); *(ptr+i) = *(ptr+len-1-i); *(ptr+len-1-i) = temp; } return (ptr); } #endif // RUN

In C the equivalent of new is malloc(sizeof(sometype))

In Programming language, how much the importance of math?

Not exactly constructor isnt called

Ah, true You can also use this method in C++ (malloc(sizeof)) if you don't want new to call the constructor

In Programming language, how much the importance of math?

#include <stdio.h> #define RUN int str_len(char *); // Calculating the length of String through Pointer. char *str_reverse(char *); // Reversing a String through Pointer. #ifdef RUN int main() { char *str = "Computer"; printf("Length of the String is: %d\n", str_len(str)); printf("Reversed String is: %s\n", str_reverse(str)); return 0; } int str_len(char *ptr) { int i; for (i=0; *(ptr+i)!='\0'; i++); return i; } char *str_reverse(char *ptr) { int len; printf("%d", len); for (len=0; *(ptr + len) != '\0'; len++); for (int i = 0; i < len/2; i++) { // Swapping char temp = *(ptr+i); *(ptr+i) = *(ptr+len-1-i); *(ptr+len-1-i) = temp; } return (ptr); } #endif // RUN