C++中静态成员函数访问非静态成员变量
XXX14秋学期《面向对象程序设计》在线作业答案
XXX14秋学期《面向对象程序设计》在线作业答案面向对象程序设计14秋学期《面向对象程序设计》在线作业一,单选题1.下列关于this指针的说法,错误的是()。
A。
this指针指向当前正在操作的对象B。
this指针只存在于非静态成员函数中C.在成员函数中对非静态数据成员的访问是通过this指针完成的D.静态成员函数中可以通过this指针访问非静态成员正确答案：D2.已知“int a=10,*p;int *&r=p。
r=*p=20;cout<<a;”，则输出为()。
A。
10B。
20C.不确定值D.程序有错误正确答案：B3.有关重载函数的描述正确的是()。
A.函数名相同的函数就是重载函数B.函数名相同但返回值类型不同的函数就是重载函数C.函数名相同但参数个数或类型不同的函数就是重载函数D.函数功用相同的函数就是重载函数正确答案：C4.在表达式x+y*z中，+是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。
以下叙述中正确的选项是()。
A。
operator+有两个参数，operator*有两个参数B。
operator+有两个参数，operator*有一个参数C。
operator+有一个参数，operator*有两个参数D。
operator+有一个参数，operator*有一个参数正确谜底：C5.以成员函数方式重载运算符“>”，则obj1>obj2被C++编译器解释为()。
A。
operator>(obj1,obj2)B。
(obj1,obj2)C。
obj1.operator>(obj2)D。
obj2.operator>(obj1)正确谜底：C6.下列运算符中，()在C++中不能重载。
A。
:B。
+C。
-D。
<=正确答案：A7.运行以下程序时，如果由键盘输入6514，则输出结果是()。
#includeusingnamespace std。
int main() { int m。
c++的static关键字用法
c++的static关键字用法C++中的`static`关键字有多种用法，在不同的场景下都有着不同的含义和作用。
本文将详细介绍C++中`static`关键字的用法及其相关特性，希望能对读者更好地理解和运用这个关键字。
一、`static`关键字概述`static`是C++中的一个关键字，它常用于指定函数、变量、类成员等的作用域和生命周期。
它的主要作用如下：1. 限定变量的作用域。
使用`static`关键字声明的变量具有静态的生存期和块作用域，即在整个程序运行期间都存在，并且只能在声明变量的源文件中访问。
2. 限定函数的作用域。
使用`static`关键字声明的函数具有静态的作用域，即只能在声明它的源文件中调用。
3. 限定类成员的作用域。
使用`static`关键字声明的类成员为静态成员，它不属于类的任何一个对象，而是属于整个类，可以通过类名或类对象来访问。
4. 防止符号重定义。
当在多个源文件中定义同名的全局变量或函数时，使用`static`关键字可以防止它们之间的符号重定义错误。
二、静态变量1. 全局静态变量使用`static`关键字声明的全局变量具有静态生存期和文件作用域，即它在程序运行期间一直存在，而且只能在声明它的源文件中访问。
例如：```cpp//file1.cpp#include <iostream>static int count = 10; //声明全局静态变量countvoid func() {static int i = 5; //局部静态变量i，生命周期为整个程序运行期间std::cout << "i is " << i ;std::cout << " and count is " << count << std::endl;i++;count++;}```在另一个源文件中引用这个全局静态变量，编译器会报错：```cpp//file2.cpp#include <iostream>extern int count; //声明全局变量countvoid func2() {std::cout << "count is " << count << std::endl;}```编译器会报错：undefined reference to `count'。
C++类静态成员与类静态成员函数详解
C++类静态成员与类静态成员函数详解当将类的某个数据成员声明为static时，该静态数据成员只能被定义⼀次，⽽且要被同类的所有对象共享。
各个对象都拥有类中每⼀个普通数据成员的副本，但静态数据成员只有⼀个实例存在，与定义了多少类对象⽆关。
静态⽅法就是与该类相关的，是类的⼀种⾏为，⽽不是与该类的实例对象相关。
静态数据成员的⽤途之⼀是统计有多少个对象实际存在。
静态数据成员不能在类中初始化，实际上类定义只是在描述对象的蓝图，在其中指定初值是不允许的。
也不能在类的构造函数中初始化该成员，因为静态数据成员为类的各个对象共享，否则每次创建⼀个类的对象则静态数据成员都要被重新初始化。
静态成员不可在类体内进⾏赋值，因为它是被所有该类的对象所共享的。
你在⼀个对象⾥给它赋值，其他对象⾥的该成员也会发⽣变化。
为了避免混乱，所以不可在类体内进⾏赋值。
数据类型类名：：静态数据成员名＝初值不能⽤参数初始化表对静态成员初始化。
⼀般系统缺省初始为0。
静态成员是类所有的对象的共享的成员，⽽不是某个对象的成员。
它在对象中不占⽤存储空间，这个属性为整个类所共有，不属于任何⼀个具体对象。
所以静态成员不能在类的内部初始化，⽐如声明⼀个学⽣类，其中⼀个成员为学⽣总数，则这个变量就应当声明为静态变量，应该根据实际需求来设置成员变量。
复制代码代码如下:#include "iostream"using namespace std;class test{private:int x;int y;public:static int num;static int Getnum(){x+=5; // 这⾏代码是错误的，静态成员函数不能调⽤⾮静态数据成员，要通过类的对象来调⽤。
num+=15;return num;}};int test::num = 10;int main(void){test a;cout<<test::num<<endl; //10test::num = 20;cout<<test::num<<endl; //20cout<<test::Getnum()<<endl; //35cout<<a.Getnum()<<endl; //50system("pause");return 0;}通过上例可知： x+=5; // 这⾏代码是错误的静态函数成员必须通过对象名来访问⾮静态数据成员。
C++类中的静态成员变量和静态成员函数的作用
数据成员可以分静态变量、非静态变量两种.静态成员：静态类中的成员加入static修饰符,即是静态成员.可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态的成员..因为静态成员存在于内存,所以非静态成员可以直接访问类中静态的成员.非成静态员：所有没有加Static的成员都是非静态成员,当类被实例化之后,可以通过实例化的类名进行访问..非静态成员的生存期决定于该类的生存期..而静态成员则不存在生存期的概念,因为静态成员始终驻留在内容中..一个类中也可以包含静态成员和非静态成员,类中也包括静态构造函数和非静态构造函数..分两个方面来总结，第一方面主要是相对于面向过程而言，即在这方面不涉及到类，第二方面相对于面向对象而言，主要说明static在类中的作用。
一、在面向过程设计中的static关键字1、静态全局变量定义：在全局变量前，加上关键字static 该变量就被定义成为了一个静态全局变量。
特点：A、该变量在全局数据区分配内存。
B、初始化：如果不显式初始化，那么将被隐式初始化为0(自动变量是随机的,除非显式地初始化)。
C、访变量只在本源文件可见，严格的讲应该为定义之处开始到本文件结束。
例〔摘于C++程序设计教程---钱能主编P103〕：//file1.cpp//Example 1#include <iostream.h>void fn();static int n; //定义静态全局变量void main(){n=20;cout < <n < <endl;fn();}void fn(){n++;cout < <n < <endl;}D、文件作用域下声明的const的常量默认为static存储类型。
静态变量都在全局数据区分配内存，包括后面将要提到的静态局部变量。
对于一个完整的程序，在内存中的分布情况如以下图：代码区全局数据区堆区栈区一般程序的由new产生的动态数据存放在堆区，函数内部的自动变量存放在栈区。
C++静态成员变量和静态成员函数的使用方法总结
C++静态成员变量和静态成员函数的使⽤⽅法总结⼀．静态成员变量：类体中的数据成员的声明前加上static关键字，该数据成员就成为了该类的静态数据成员。
和其他数据成员⼀样，静态数据成员也遵守public/protected/private访问规则。
同时，静态数据成员还具有以下特点：1.静态数据成员的定义。
静态数据成员实际上是类域中的全局变量。
所以，静态数据成员的定义(初始化)不应该被放在头⽂件中。
其定义⽅式与全局变量相同。
举例如下：xxx.h⽂件class base{private:static const int _i;//声明，标准c++⽀持有序类型在类体中初始化,但vc6不⽀持。
};xxx.cpp⽂件const int base::_i=10;//定义(初始化)时不受private和protected访问限制.备注：不要在头⽂件中定义(初始化)静态数据成员。
在⼤多数的情况下，这样做会引起重复定义这样的错误。
即使加上#ifndef #define #endif或者#pragma once也不⾏。
2.静态数据成员被类的所有对象所共享，包括该类派⽣类的对象。
即派⽣类对象与基类对象共享基类的静态数据成员。
举例如下：class base{public :static int _num;//声明};int base::_num=0;//静态数据成员的真正定义class derived:public base{};main(){base a;derived b;a._num++;cout<<"base class static data number _numis"<<a._num<<endl;b._num++;cout<<"derived class static data number _numis"<<b._num<<endl;} // 结果为1,2;可见派⽣类与基类共⽤⼀个静态数据成员。
C#中的静态方法如何调用静态方法
C#中的静态⽅法如何调⽤静态⽅法C#的类中可以包含两种⽅法：静态⽅法和⾮静态⽅法。
使⽤了static 修饰符的⽅法为静态⽅法，反之则是⾮静态⽅法。
静态⽅法是⼀种特殊的成员⽅法，它不属于类的某⼀个具体的实例，⽽是属于类本⾝。
所以对静态⽅法不需要⾸先创建⼀个类的实例，⽽是采⽤类名.静态⽅法的格式。
1.static⽅法是类中的⼀个成员⽅法,属于整个类,即不⽤创建任何对象也可以直接调⽤!static内部只能出现static变量和其他static⽅法!⽽且static⽅法中还不能使⽤this....等关键字..因为它是属于整个类!2.静态⽅法效率上要⽐实例化⾼，静态⽅法的缺点是不⾃动进⾏销毁，⽽实例化的则可以做销毁。
3.静态⽅法和静态变量创建后始终使⽤同⼀块内存，⽽使⽤实例的⽅式会创建多个内存.4.C#中的⽅法有两种:实例⽅法,静态⽅法.类的⽅法代码只有⼀份,它们的⽣命周期和类是⼀致的.实例⽅法是通过对象名调⽤的,静态⽅法与类关联⽽不是与对象名关联.5.那么在程序中什么地⽅可以利⽤静态字段和静态构造⽅法，通常适⽤于于⼀些不会经常变化⽽⼜频繁使⽤的数据，⽐如连接字符串，配置信息等，当满⾜上⾯所说的两点时，进⾏⼀次读取，以后就可以⽅便的使⽤了，同时也节约了托管资源，因为对于静态成员，⼀个静态字段只标识⼀个存储位置。
对⼀个类⽆论创建了多少个实例，它的静态字段永远都只有⼀个副本(副本我理解为只有⼀块内存静态成员存在于内存,⾮静态成员需要实例化才会分配内存,所以静态成员不能访问⾮静态的成员..因为静态成员存在于内存,所以⾮静态成员可以直接访问类中静态的成员. 公⽤的处理函数,使⽤静态⽅法应该没有问题..牵涉到数据共享,静态变量的函数要多考虑...静态变量要⼩⼼使⽤..静态⽅法原理就是共享代码段共享代码段不会产⽣任何问题因为代码段都是给CPU作为"读取"⽤的,除⾮你进⾏恶意"修改"运⾏时的代码段所以静态⽅法是可以放⼼使⽤的静态变量原理就是共享数据段同上只要没有进⾏"写⼊"操作就不会产⽣问题但是数据通常都是⽤于读和写所以静态变量要注意使⽤下⾯是⼀个使⽤静态⽅法的例⼦ class Class1{[STAThread]static void Main(string[] args){int i = MyClass.Add(3,5); //调⽤静态⽅法Console.WriteLine(i);}}class MyClass{public static int Add(int x,int y ){return x + y ;} }。
static 用法
static 用法static 用法1. static 变量•定义：在函数内部使用 static 关键字声明的变量称为静态变量。
•特点：–静态变量的生命周期在整个程序运行期间都存在，而不仅仅在函数调用时才存在。
–静态变量存储在静态存储区，不会在函数调用结束后释放内存。
•使用场景：–如果一个变量需要在多次函数调用之间保持其值不变，可以使用静态变量。
–静态变量通常用于计数器或者保存函数的返回值等场景。
•示例代码：#include <>int count() {static int counter = 0;counter++;return counter;}int main() {printf("%d\n", count()); // 输出1printf("%d\n", count()); // 输出2printf("%d\n", count()); // 输出3return 0;}2. static 函数•定义：在函数返回类型前面加上 static 关键字，使函数变为静态函数。
•特点：–静态函数只能在声明它的源文件内部调用，不能被其他源文件使用。
–静态函数不能被其他源文件中的函数调用，从而起到了隐藏的作用。
•使用场景：–当某个函数只在当前源文件内部使用时，可以将其声明为静态函数，以减少命名冲突和提高代码的模块化程度。
•示例代码：#include <>static int multiply(int a, int b) {return a * b;}int main() {int result = multiply(2, 3);printf("%d\n", result); // 输出6return 0;}3. static 类成员•定义：在类中声明的 static 成员属于类本身，而不是类的实例。
•特点：–所有的对象共享同一个静态成员，即静态成员对于所有的对象来说只有一份拷贝。
C语言static和const的区别
C语⾔static和const的区别static:1、不考虑类，static的作⽤：1)第⼀个作⽤：隐藏。
使得全局变量和函数对其它⽂件不可见，同时避免了不同⽂件的命名冲突。
2)第⼆个作⽤：默认初始化为0。
未初始化的全局静态变量和局部静态变量都保存在BBS段，BBS段的特点是，程序运⾏之前会⾃动清零。
3)第三个作⽤：保持局部变量内容的持久性。
此变量声明周期是整个程序的声明周期，但是作⽤域只在声明它的函数中。
2、类中的static，表⽰属于某个类单数不属于类的任何特定对象的变量和函数。
1)对于类的静态数据成员：a、类的静态数据成员独⽴于该类的任意对象⽽存在；其值的修改被类的所有对象看见。
b、static数据成员必须在类定义的外部定义，通常放在包含类的⾮内联成员函数定义的⽂件中。
class A{stctic double d = 0.03;//错误};c、但是也有例外，const static 数据成员可以在类的定义体中进⾏初始化，因为const定义时必须初始化。
2)对于类的成员函数：a、static成员函数由于不与任何对象关联，因此它不具备this指针，因此，它⽆法访问属于类对象的⾮静态数据成员，也⽆法访问⾮静态成员函数。
也就是说，类的静态成员函数，只能调⽤该类的其它静态成员函数和静态数据成员。
b、static成员不是任何对象的组成部分，所以成员函数不能被声明为const。
此外，static成员函数也不可以声明为virtual,volatile。
关于静态成员函数的总结：(1)静态成员之间可以相互访问，不能访问⾮静态成员。
⾮静态成员函数可以任意访问静态和⾮静态成员。
(2)静态函数执⾏速度⽐⾮静态函数稍快。
const:1、const定义后就不能修改，因此定义时要初始化。
2、在C语⾔中const buffsize = 10;int buf[buffsize];是错误的；⽽在C++中是正确的。
C中改为const int buffsize；3、使⽤const⽐使⽤#define有更多的优点：1)const常量有数据类型，⽽宏常量没有。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C++中静态成员函数访问非静态成员变量
这两天写一个简单的程序，由于程序运行占用cpu比较厉害，导致运行中界面窗口无法交互，因此想到了多线程，以前没有接触过mfc多线程，在网上看了两篇文章，觉得也不过如此，就开始动手写了，结果发现即使是看别人写很简单，自己动手也会出现很多问题，哪怕是看起来真的很简单的问题。
这里遇到的问题就是由于多线程的函数必须是static的，然后需要在里面调用non-static的函数，我就没有办法了，于是又开始网上找资料，下面就将这篇文章转贴过来，供大家学习思考：先看一个class class a { public:
static FunctionA() {
menber = 1; } private: int menber; }
编译上述代码，出错。
原因很简单大家都知道，静态成员函数不能访问非静态成员，这是因为静态函数属于类而不是属于整个对象，静态函数中的 member可能都没有分配内存。
静态成员函数没有隐含的this自变量。
所以，它就无法访问自己类的非静态成员。
（看过一篇很好的文章《浅析C++中的this指针》介绍这个方面的详细内容）那要想访问怎么办呢？地球人都知道只要将： int menber;
//change the line above to: static int menber;
但是这个方法让我们不得不将static function内用到的成员变量都变成static的了，而且static 的成员还要显式初始化，有没有更好的方法？答案是肯定的。
如下： class a { public:
static FunctionA(a* _a) {
a-> menber = 1; (window.cproArray = window.cproArray || []).push({ id: "u2280119" }); } private: int menber; }
前提是这个类要分配了内存空间。
其实这里我做的就是将一个对象指针作为静态成员函数的“this”指针，意在模仿传递非静态成员函数里this变量。