零散3

最新推荐文章于 2022-09-08 20:57:43 发布

誉愿、

最新推荐文章于 2022-09-08 20:57:43 发布

阅读量290

点赞数

分类专栏：零散

本文链接：https://blog.csdn.net/mi6666/article/details/113852991

版权

零散专栏收录该内容

4 篇文章 0 订阅

订阅专栏

零散3

Test执行后的输出是： 

void Test {
    class B {
        public:
        B( void )
        {
            cout << "B\t";
        }

    ~B( void )
    {
        cout << "~B\t";
    }
};
struct C {
    C( void )
    {
        cout << "C\t";
    }

    ~C( void )
    {
        cout << "~C\t";
    }
};
struct D : B {
    D { cout << "D\t"; }
    ~D { cout << "~D\t"; }
    private: C c;
};
D d;

}

B C D ~D ~ C ~B

  D继承自B,基类的构造函数先执行，没有疑问。 

  C是D的成员函数，在D的构造函数开始前，会对其进行初始化所以执行C的构造函数。 

  最后执行D的构造函数。 

  析构函数执行的顺序与构造相反。

sizeof( double )是一个整型表达式

char * const p; 指针常量，p的值不可以修改
char const * p；指向常量的指针，指向的常量值不可以改
const char *p；常量指针，指针p所指向的变量为常量，但是p是可以修改的

i++在计算时，会用到中间变量存储，会占用更多的内存和时间。所以++i更好。

若有定义语句:char s [3] [10],(* k)[3],*p;则以下赋值语句错误的是(124) 
1.p=s;   2.p=k;   3.p=s[0];    4.k=s;
s是一个二维数组，但也可以看成是一个包含3个元素的一维数组，每个元素又是一个包含10个元素的一维数组。s这个名字本身的值是指向它第一个元素的指针。也就是说，s的值是指向包含3个元素的一维数组的第一个元素的指针。即第一个包含10个元素的一维数组的指针。k是一个指针，而不是指针数组。k指向一个包含3个元素的一维数组的指针。 
简单说，s是指向一维数组的常量指针，数组包含10个元素。k是指向一维数组的变量指针，数组包含3个元素。而p是指向单个变量的指针。如果一个变量算一个单位长，那么s+1就意味着指针走了10个单位长，k+1就意味着走了3个单位长，p+1就意味着走了1个单位长。

由于友元函数可以直接访问对象的私有成员，所以友元的作用是提高程序运行的效率。

下面程序段中，for循环的执行次数是（6）。
char *s="\ta\018bc"；
for(; *s!=’\0';s++)  printf("*”)；

\ddd(d为任意数字)在转义字符中表示三位八进制，因为八进制中的数只有0-7，因此\018不能表示三位八进制，所以取\01。而\t在转义字符中表示制表符，所以\t算一次。然后a一次，\01一次，8一次，b一次，c一次。所以是6次。

数组只能省略第一维
已知fun(int)是类Test的公有成员函数，p是指向成员函数fun()的指针，采用p=&Test::fun是正确的。
scanf不能指定输入精度，可以指定长度。比如%m.nf是不允许的，但是可以%mf。m为整数。

联合变量定义时可初始化
联合的成员是共址的
联合的成员在某一个时刻只有当前的是有效的
联合变量占有的内存空间是该联合变量中占有最大内存空间的成员在内存对齐时所需的存储空间

  dynamic_cast :  

  继承体系安全向下转型或跨系转型；找出某对象占用内存的起始点 

  static_cast: 

  同旧式C转型，如int 到double 

  const_cast: 

  常用于去除某个对象的常量性 

  reinterpret_cast 

  不具备移植性，常见用途是转化函数指针类型

在gcc编译器中，下面程序的运行结果是（2  随机值）。 

#include<stdio.h>
int main(void)
{
    int x[5] = {2,4,6,8,10},* p;  int (* pp)[5];
    p=x;
    pp=&x;
    printf ("%d\n",* (p++));
    printf ("%d\n",* pp);
}

  第一个打印的是指针指向x数组的值，也就是x[0],然后指针变量自加1； 

  第二个打印的是x数组的首地址（pp=&x），但每次分配都不相同，所以随机。

C语言中，设a=3,b=4,执行语句“printf("%d,%d",(a,b),(b,a))；”的输出结果是（4,3）
逗号表达式从左往右执行，最后显示最右边的那个。

在传值调用中，类型可不一致，允许实参个数比形参少（含有默认参数）

下面程序的输出结果是（false,false,true）
#include <iostream>
using namespace std;

int main() 
{
    char str1[] = "hello world";  
    char str2[] = "hello world";  

const char str3[] = "hello world";  
const char str4[] = "hello world";  

const char* pstring1 = "hello world";  
const char* pstring2 = "hello world";  

cout << boolalpha << ( str1==str2 ) <<  ',' ; //比较字串首地址
cout << boolalpha << ( str3==str4 ) << ',' ;  //比较字串首地址
cout << boolalpha << ( pstring1==pstring2 ) <<endl;
                                           //比较指针所指地址
return 0;

}

浮点型默认为double型的

下列 C 代码中，不属于未定义行为的有：C
int i=0;i=(i++);
char *p=”hello”;p[1]=’E’
char *p=”hello”;char ch=*p++
int i=0;printf(“%d%d\n”,i++,i--)

A选项，不知道编译器会怎么选择自增和赋值的顺序，所以这是由编译器决定的，属于未定义行为。
B选项，”hello“这个字符串属于一个字符串常量了，指针p指向了这个字符串常量，通过这个指针来直接修改常量第二个字符，这也属于未定义行为。
C选项，只是通过指针找到第二个字符并将它赋值给一个字符变量，并没有改变这个字符串常量，所以不属于未定义行为。
D选项，在printf语句中，i++和i–谁先执行由编译器决定，这是未定义行为。

静态语言（强类型语言） 
静态语言是在编译时变量的数据类型即可确定的语言，多数静态类型语言要求在使用变量之前必须声明数据类型。  
例如：C++、Java、C、C#等。

main()
 { char * p="abcdefgh",*r;
long * q;
q=(long * )p;
q++;
r=(char*)q;
 printf("%s\n",r);
}
efgh
long是4个字节。一次移动4个char了

假定s被定义为指针类型char *的变量，初始指向的字符串为"Hello world!"，若要使变量p指向s所指向的字符串，则p应定义为char *p=s
int y[5+3]={0, 1, 3, 5, 7, 9};是正确的
#define后不加分号格式 #define 新类型名旧类型名 typedef后要加分号格式 typedef 旧类型新类型；

#include <stdio.h>
int main()
{ 
int i, j, m=6,n=4,  *p=&n, *q=&m;

i=p==&m;
j=(-* p)/(*q)+7;

printf("i=%d,j=%d\n", i,j);

return 0;
}
i=0,j=7

i=p==&m;
从后结合，先计算 p==&m,p 显然是n,前后两者不相等，返回结果为了false，即是0，所以i=0；
j=(-*p)/(*q)+7;
j=(-n)/m+7,先计算除法，（-n）/m=0 , j=0+7=7;
所以 i 等于0，j 等于7。

已知int a [3] [3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };  不能表示数组元素a [2] [1]的地址是（B）。 
&a[2][1]
*(a[2]+1)
a[2]+1
*(a+2)+1

#define X 5 
#detine Y X+1 
#define Z Y*X/2 
void main() 
{ 
int a=Y；
printf("%d,%d",Z,--a)；
} 
7,5
先来计算Z的值，Z将替换成Y*X/2，再把X+1替换Y，得Z=X+1*X/2，再用5替换X，得Z=5+1*5/2，所以Z的值是7（注意整除）。a=Y宏替换后变成a=X+1，再将5替换X，得a=5+1，即a的值是6，但输出是--a，a先减1即变为5，再输出。

声明一个指向含有10个元素的数组的指针，其中每个元素是一个函数指针，该函数的返回值是int，参数是int*，正确的是int (*(*p)[10])(int *)
先看未定义标识符p，p的左边是*，*p表示一个指针，跳出括号，由于[]的结合性大于*，所以*p指向一个大小为10的数组，即(*p)[10]。左边又有一个*号，修释数组的元素，*(*p)[10]表示*p指向一个大小为10的数组，且每个数组的元素为一个指针。跳出括号，根据右边（int *）可以判断（*(*p)[10]）是一个函数指针，该函数的参数是int*,返回值是int。

开发C代码时,经常见到如下类型的结构体定义: 

typedef struct list_t{
struct list_t *next;
struct list_t *prev;
char data[0];
}list_t;

请问在32位系统中,sizeof(list_t)的值为? 8byte

柔性数组：

把单一元素的数组放在一个struct的尾端，使得每个struct对象可以拥有可变大小的数组。 

开始题目中的char data[0]或写成char data[]，即为柔性数组； 

data不占用struct的空间，只是作为一个符号地址存在。   因此sizeof的值是两个指针所占字节，即4+4 = 8字节。

若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度
动态全局变量、静态全局变量、静态局部变量的生命周期都为程序运行期间
全局变量和静态变量都是存储在静态存储区，所以在递归调用是不会压栈，也不会造成堆栈溢出。

下面代码在32位计算机中输出的结果是4 
struct TEST_TYPE
{
int a;
int b;
};
int testSize(struct TEST_TYPE val[10])
{
return sizeof(val);
}

子函数中传递的数组被当成指针对待，sizeof()以后只是一个指针的大小

fgetc 函数的作用是从指定文件读入一个字符，该文件的打开方式必须是（追加）或（读或读写）

How many times is f() called when calculating f(10)? 15

int f(int x) { 
    if(x <= 2) 
        return 1; 
    return f(x - 2) + f(x - 4) + 1; 
}

                                       10 

                               8                  6 

                         6         4        4       2 

                     4    2      2   0      2   0 

                  2   0

32位机器上，以下结构的sizeof(P)为40

struct A {
 int a;
 char b;
 int c;
 char d;
}
struct P {
 struct A w[2];
 short b;
 struct A* p;
}  

  struct A { 

  int a;                            //4 bytes 

  char b;                        //1 bytes 

  //char pad[3]               //3 bytes 

int c;                           //4 bytes

  char d;                       //1 bytes 

  //char pad[3]              //3 bytes 

  }                            // total = 16 bytes 

  /* P中有结构体A的成员，但是计算时按照A中数据类型确定的*/ 

struct P {

struct A w[2];    // 2 * 16 bytes

  short b;            //2 bytes 

  //char pad[2]    //2 bytes 

struct A* p;      //4 bytes

}  // total = 40 bytes

构造函数可以被重载
构造函数可以是内联函数
构造函数可以没有参数
构造函数和析构函数是两个非常特殊的函数：它们没有返回值

誉愿、

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
零散3

零散3Test执行后的输出是： void Test { class B { public: B( void ) { cout << "B\t"; } ~B( void ) { cout << "~B\t"; }};struct C { C( void ) { cout << "C\t";
复制链接

扫一扫

专栏目录