sizeof

I have this program #include <stdio.h> int main() { char arr[100]; printf("%d", (int)sizeof(0,arr)); } This prints 4 when compiled as a C file and prints 100 as a C++ file. Why? I am using gcc. In C the result of the right hand operand of the comma operator has a type and value . In C a comma operator does not yield an lvalue. So there is an lvalue to rvalue conversion resulting in decay of array type to pointer type. So in C what you get is the result of sizeof(char*) . In C++ the result of a comma expression is an lvalue. There is no such conversion[as in C] and what you get is the sizeof

Let us assume I have declared the variable 'i' of certain datatype (might be int, char, float or double) ... NOTE: Simply consider that 'i' is declared and dont bother if it is an int or char or float or double datatype. Since I want a generic solution I am simply mentioning that variable 'i' can be of any one of the datatypes namely int, char, float or double. Now can I find the size of the variable 'i' without sizeof operator? You can use the following macro, taken from here : #define sizeof_var( var ) ((size_t)(&(var)+1)-(size_t)(&(var))) The idea is to use pointer arithmetic ( (&(var)+1) )

网上看了很多文章，都说 fread 比 read 读取数据更快云云，今天在我的 mac 上做了一个小测试，结果比较意外 1 #include <stdio.h> 2 #include <unistd.h> 3 #include <time.h> 4 #include <fcntl.h> 5 6 void test_fread(char *buff, int num); 7 void test_read(char *buff, int num); 8 9 int main() { 10 char buff[100]; 11 test_fread(buff, sizeof(buff)); 12 test_read(buff, sizeof(buff)); 13 } 14 15 void test_fread(char *buff, int num) { 16 clock_t start, finish; 17 double duration; 18 start = clock(); 19 20 FILE *fp; 21 char filename[] = "a.txt"; 22 fp = fopen(filename, "r"); 23 int i=0; 24 while(1) { 25 i++; 26 fread(buff, num, 1, fp); 27 if(feof(fp))

I'm trying to do something along the lines of this using GCC 4.7 snapshot: template <int n, int... xs> struct foo { static const int value = 0; }; // partial specialization where n is number of ints in xs: template <int... xs> struct foo<sizeof...(xs), xs...> { // error: template argument ‘sizeof (xs ...)’ // involves template parameter(s) static const int value = 1; }; template <int... xs> struct foo<sizeof(xs), xs...> { // This compiles fine. sizeof(xs) is sizeof int // even though packs aren't expanded static const int value = 2; }; The error is strange because sizeof instead of sizeof...

Considering : double data; double array[10]; std::vector<int> vec(4, 100); MyClass myclass; Is there a difference between : sizeof(double); sizeof(double[10]); sizeof(std::vector<int>); sizeof(MyClass); and sizeof(data); sizeof(array); sizeof(vec); sizeof(myclass); Are the two syntaxes different or strictly equivalent ? Are all of them evaluated at compile-time ? If not, which one is evaluated at run-time ? The only differences are in syntax and convenience. Syntactically, you're allowed to leave out the parentheses in one case, but not the other: double d; sizeof(double); // compiles sizeof(d