C++ 一些知识点

来源：互联网发布：linux监控tomcat进程编辑：程序博客网时间：2024/06/03 19:30

一）

1 友元函数和友元类均可以访问private \protected成员；

2 友元函数和友元类能够引用类中的private \protected成员，但是在其内部引用时必须通过对象引用，比如函数体中a.x，b.x，a.y，b.y都是类的私有成员，他们是通过对象引用的。

3 友元函数在外部调用时，不需要通过基类的对象 “ . ” 或者对象指针 “-> ” 来调用，因为它是一个普通函数，不是类成员函数，调用跟普通函数方式一样；

4 友元函数在基类外部定义，且定义时不需要加 :: 符号。

5 友元函数和友元类在基类内部声明时在哪个位置都一样，包括public\private\protected位置;

二

int a={1,2,3,4}; int *p=(int *)((int)a+1); P指向了什么？
1. int a = {}; 貌似应该是int a[] = ｛｝;
2. "(int)a"，已经把a的地址强转成int型数字（32bit）,所以“((int)a+1); ”实际指向了整个数组内存块的第二个地址，即a[0]的第二个字节。所以p的指向就向前移动了一个字节，指向了a【0】的第二个字节的地址。

三

剑指offer T48

四

1 char pData[] = "i am a student."; char *pData = "i am a student.";

后者字符串如果为指针型表示，则此字符串为const类型，不可以更改此字符串内容，但是前者数组的形式可以。

比如char *func(char *pData) 此函数的指针输入参数只能选择前者char pData[] = "i am a student."; 选择后者作为参数会出错！！

五-1

class Base {

public:

 virtual void f() { cout << "Base::f" << endl; }

 virtual void g() { cout << "Base::g" << endl; }

 virtual void h() { cout << "Base::h" << endl; }
};

class Derive :public Base
{
public:

 void f() { cout << "Derive::f1" << endl; }

 void g1() { cout << "Derive::g1" << endl; }

 virtual void h1() { cout << "Derive::h1" << endl; }
};

虚函数的多态性只发生在指针或者引用调用的情况下!!!!!!!看下面运行的对比例子！！

Base *b1 =& b;
b1->f(); ///////Derive::f1

Base b1 =b;
b1.f(); ///////Base::f

五-2

class Base {

public:

 Base()
 {
 f();
 }
 virtual void f()
 {
 cout <<" gouzao base" << endl;
 }
};

class Derived :public Base
{
public:
 Derived()
 {};
 void f()
 {
 cout << "gou zao derived" << endl;
 }

};

int main()

{
 Base *p = new Derived;
 p->f();

 system("pause");
 return 0;

}

输出结果 gouzao base

gou zao derived

在一开始调用构造函数的时候，运行构造函数前，对象还没有生成，更谈不上调用动态类型了！！尽管对象是个derived，但是构造基类部分时，还只是个base，所以会调用基类的虚函数f().

五-3

class Base {

public:

 Base()
 {
 f();
 }
 virtual void f()
 {
 cout << " gou zao base" << endl;
 }
 ~Base()
 {
 cout << "base~" << endl;
 f();
 }
};

class Derived :public Base
{
public:
 Derived()
 {};
 void f()
 {
 cout << "gou zao derived" << endl;
 }
 ~Derived()
 {
 cout << "derived~" << endl;
 f();
 }

};

int main()

{
 Base *p = new Derived;
 p->f();
 delete p;//注意此时应该是如果析构函数不是虚函数，只掉用基类析构函数，我看输出结果，此时f() 也是只掉用基类的f()" gou zao base",不涉及继承类的多态问题！！
 p = NULL;
 system("pause");
 return 0;
}

基类指针指向继承类时，此时当用基类指针delete，需要将析构函数设置为virtual函数形式，否则只会调用基类的析构函数，不会调用派生类对象自身的析构函数！

（类中的静态函数不可以设置为虚函数，因为虚函数都是通过具体对象的虚函数表来实现的，而静态函数不属于具体对象，自然没有虚函数表，它在创建具体对象之前就已经存在了！）

六

int main(){

unsignedchara=0xA5;

unsignedcharb=~a>>4+1;

printf("%d\n",b);

return0;

}
所以优先级顺序是：~、+大于>>大于=，先做a的取反操作，然后4+1为5，然后~a>>5，然后赋值给b

下面，如果按照我们的常识，a取反右移5位应该是2才对，但是答案是250，对250分析可知，当~a右移时，前面补的是1，而不是0，为什么呢？

因为，无论是unsigned char，还是unsigned short、short、char等，都是转换成int来处理的，一般情况下，int为32位，所以a取反后是ffffff5a，右移5位，前面补1（最高位为1，在计算机中认为是负数，补1，如果是unsigned int型的变量的话，前面补0），最后转化成unsigned char型，所以取后8位是fa，即250

七

面试题：构造函数

#include <iostream>
using namespace std;

class Base
{
private:
int i;
public:
Base(int x)
{
i = x;
}
};

class Derived : public Base
{
private:
int i;
public:
Derived(int x, int y)
{
i = x;
}
void print()
{
cout << i + Base::i << endl;
}
};

int main()
{
Derived A(2,3);
A.print();
return 0;
}

首先，是访问权限问题，子类中直接访问Base::i是不允许的，应该将父类的改为protected或者public（最好用protected）

其次，统计父类和子类i的和，但是通过子类构造函数没有对父类变量进行初始化；此处编译会找不到构造函数，因为子类调用构造函数会先找父类构造函数，但是没有2个参数的，所以可以在初始化列表中调用父类构造函数

最后个问题，是单参数的构造函数，可能存在隐式转换的问题，因为单参数构造函数，和拷贝构造函数形式类似，调用时很可能会发生隐式转换，应加上explicit关键字

#include <iostream>
using namespace std;

class Base
{
protected:
int i;
public:
explicit Base(int x)
{
i = x;
}
};

class Derived : public Base
{
private:
int i;
public:
Derived(int x, int y):Base(x)
{
i = y;
}
void print()
{
cout << i + Base::i << endl;
}
};

int main()
{
Derived A(2,3);
A.print();
return 0;
}

2、初始化列表

1）使用初始化列表提高效率

class Student
{
public:
Student(string in_name, int in_age)
{
name = in_name;
age = in_age;
}
private :
string name;
int age;
};

因为在构造函数中，是对name进行赋值，不是初始化，而string对象会先调用它的默认构造函数，再调用string类（貌似是basic_string类）的赋值构造函数；对于上例的age，因为int是内置类型，应该是赋值的时候获得了初值。

要对成员进行初始化，而不是赋值，可以采用初始化列表（member initialization list）

class Student
{
public:
Student(string in_name, int in_age):name(in_name),age(in_age) {}
private :
string name;
int age;
};

在初始化的时候调用的是string的拷贝构造函数，而上例会调用两次构造函数，从性能上会有不小提升

有的情况下，是必须使用初始化列表进行初始化的：const对象、引用对象

2）初始化列表初始顺序

#include <iostream>
using namespace std;

class Base
{
public:
Base(int i) : m_j(i), m_i(m_j) {}
Base() : m_j(0), m_i(m_j) {}
int get_i() const
{
return m_i;
}
int get_j() const
{
return m_j;
}

private:
int m_i;
int m_j;

};

int main()
{
Base obj(98);
cout << obj.get_i() << endl << obj.get_j() << endl;
return 0;
}

输出为一个随机数和98，为什么呢？因为对于初始化列表而言，对成员变量的初始化，是严格按照声明次序，而不是在初始化列表中的顺序进行初始化，如果改为赋值初始化则不会出现这个问题，当然，为了使用初始化列表，还是严格注意声明顺序吧，比如先声明数组大小，再声明数组这样。

C++构造函数初始化按下列顺序被调用：

首先，任何虚拟基类的构造函数按照它们被继承的顺序构造；
其次，任何非虚拟基类的构造函数按照它们被继承的顺序构造；
最后，任何成员对象的构造函数按照它们声明的顺序调用；

#include <iostream>
using namespace std;
class OBJ1{
public:
OBJ1(){ cout<<"OBJ1\n"; }
};
class OBJ2{
public:
OBJ2(){ cout<<"OBJ2\n";}
}
class Base1{
public:
Base1(){ cout<<"Base1\n";}
}
class Base2{
public:
Base2(){ cout <<"Base2\n"; }
};
class Base3{
public:
Base3(){ cout <<"Base3\n"; }
};
class Base4{
public:
Base4(){ cout <<"Base4\n"; }
};
class Derived :public Base1, virtual public Base2,public Base3, virtual public Base4//继承顺序{
public:
Derived() :Base4(), Base3(), Base2(),Base1(), obj2(), obj1(){//初始化列表
cout <<"Derived ok.\n";
}
protected:
OBJ1 obj1;//声明顺序
OBJ2 obj2;
};

int main()
{
Derived aa;//初始化
cout <<"This is ok.\n";
return 0;
}
结果：
Base2 //虚拟基类按照被继承顺序初始化
Base4 //虚拟基类按照被继承的顺序
Base1 //非虚拟基类按照被继承的顺序初始化
Base3 //非虚拟基类按照被继承的顺序
OBJ1 //成员函数按照声明的顺序初始化
OBJ2 //成员函数按照声明的顺序
Derived ok.
This is ok.

八

C++中如果子类一个变量与基类的某个变量重名了怎么办？如果B中有同名成员，则会使得父类的同名成员不可见（需要通过名空间访问），此时函数中的a实际上指B中的a，访问父类中的a需要通过A::来访问。

九

cout<<2^3<<endl;//error 运算符优先级不对应该为

cout<<(2^3)<<endl;

十

链接：https://www.nowcoder.com/questionTerminal/2b66de6a28234cd4ab8050c096476b92?pos=136&mutiTagIds=138&orderByHotValue=1
来源：牛客网

int a[3][4]，下面哪个不能表示 a[1][1]?

```
*(&a[0][0]+5)
```
```
*(*(a+1)+1)
```
```
*(&a[1]+1)
```
```
*(a[1]+1)
```

查看正确选项

正确答案：C

在二维数组中a[1]表示的是a[1][0]的地址，数组在内存中连续存储，所以a[1]+1表示的是a[1][1]的地址，所以D可以取得正确的值；

指针操作*(a+1)与a[1]等价，所以B也可以取得正确的值；

二维数组在内存中是行优先存储的，所以A中a[0][0]的地址加5可以取得正确值；

C选项错误，应改为*(&a[1][0]+1)，因为a[1]就表示a[1][0]的地址。

在VS中编译，输出a[1]和&a[1]的地址是一样的，但是a[1]+1和&a[1]+1却不一样，这是为什么呢？

只是输出来的值一样，但变量类型不同。a[1]是int *类型，而&a[1]是int (*)[4]类型。因此同样加1的时候，偏移不一样。前者只移一位，而后者要移动四维，即到二位数组的下一行。*(*(&a[1]+1))表示a[2][0]的值，也就是*（&a[1]+1）是a[2][0]的地址。
对于二维数组a[m][n]而言，a和a[0]都是首地址等价于&a[0][0]，不同之处在于a+1移动至下一行，而a[0]+1移动至下一列。即a+1指针指到a[1][0]处，而a[0]+1指针指到a[0][1];

int a[2][4] = { { 2, 5, 6, 8 }, { 22, 55, 66, 88 } };

 int c[4] = { 5, 8, 9, 4 };

 int d[3] = { 23, 12, 443 };

 int *p[4], (*q)[4];
//(我不明白为什么q=a可以，然而 p=a不可以！！答谢可否告知！！只是因为p作为第一个int数组不确定大小，但是a作为第一个数组首地址已经确定了数组大小是4个4,维的吗？？)
 q = a;

 *p = c;
 p[0] = c;
 *(p + 1) = d;
 p[1] = d;

 int i, j;

 for (i = 0; i<2; i++)

 for (j = 0; j<4; j++)

 {

 if ((i == 1) && (j == 3)) break;

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

 }

 puts("===============");

 for (i = 0; i<2; i++)

 for (j = 0; j<4; j++)

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

 cout << p[1][1] << endl;
 cout << *(*(p + 1) + 1) << endl;