标签: static-variables

我怎么能从另一个文件访问静态变量？静态变量不具有文件范围吗？

bash-3.2$ ls
a.c  b.c

bash-3.2$ cat a.c
#include <stdio.h>
static int s = 100;
int fn()
{
/*  some code */
}

bash-3.2$ cat b.c
#include <stdio.h>
#include "a.c"
extern int s;
int main()
{
printf("s = %d \n",s);
return 0;
}

bash-3.2$ gcc b.c   

bash-3.2$ a.exe
s = 100 

我有以下类定义和main().有人可以指出我为什么会收到错误吗？

#include <iostream>
#include <list>
using namespace std;

class test
{
protected:
  static list<int> a;
public:
  test()
  {
    a.push_back(150);
  }
  static void send(int c)
  {
    if (c==1)
      cout<<a.front()<<endl;
  }
};

int main()
{
  test c;
  test::send(1);
  return 0;
}

我得到的错误如下:

/tmp/ccre4um4.o: In function `test::test()':
test_static.cpp:(.text._ZN4testC1Ev[test::test()]+0x1b): undefined reference to `test::a'
/tmp/ccre4um4.o: In function `test::send(int)':
test_static.cpp:(.text._ZN4test4sendEi[test::send(int)]+0x12): undefined reference to `test::a'
collect2: ld returned 1 exit status

即使我使用c.send(1)而不是test :: send(1),错误也是一样的.在此先感谢您的帮助.

有没有办法通过识别GCC用来促进静态变量(我的函数中已存在的变量)的内部(隐藏？)变量来识别函数是否第一次被调用？

我希望从C++代码中获取这些变量.

我正在尝试创建为特定类创建的所有实例的计数器.很明显,我的代码不会self.__class__.counter超过1.我做错了什么？

 class Feature(object):
    counter = 0
    def __init__(self, line):
        self.id = self.__class__.counter
        self.__class__.counter = self.__class__.counter + 1
    def __repr__(self):
        return "Feature: id=%d name=%s" % (self.id,self.name,)

更新: 此代码实际上按预期工作.聪明的人留下了一些非常详细的解释,说明如何在python中处理静态.我投票决定关闭我的问题,但讨厌答案是否会消失.

首先让我说，我知道“静态类”不是在 C++ 中使用的东西，但我有一种情况，我相信类所持有的所有信息都应该是静态的。我试图了解是否有更好的方法来解决我的问题。

示例：我正在构建一个类来维护有关我的游戏的 的信息window，因此我可以从对象的任何实例访问当前window的width和height。这个类将在我调整大小、最小化、最大化等时被编辑。我的视频游戏永远不会有两个单独的窗口，只有单独的实例，它们都应该包含相同的数据。这是我所拥有的：

窗口.h

class Window {
    static int width;
    static int height;
public:
    Window();
    Window(int width, int height);
    static int getWindowWidth();
    static int getWindowHeight(); 
}

窗口.cpp

#include "Window.h"

int Window::width = 0;    
int Window::height = 0;

Window::Window( ) { }

Window::Window(int window_width, int window_height) {

    width = window_width;        
    height = window_height;

    SDL_CreateWindow( "Window",
                       SDL_WINDOWPOS_UNDEFINED,
                       SDL_WINDOWPOS_UNDEFINED,
                       width,
                       height,
                       SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_SHOWN
                    );
}

int getWindowWidth() {
    return …

我有一个包含3个静态变量的struct(someUrl):

struct someUrl {
    static var keywords = String()
    static var someUrlStart = String()
    static var someUrlEnd = String()
}

以及一个类型为someUrl的类(Url):

class Url {
    var someUrlConstructor: someUrl

    init(keywords: String, someUrlEnd: String, someUrlStart: String) {
        self.someUrlConstructor = someUrl(someUrlStart = someUrlStart, keywords = keywords, someUrlEnd = someUrlEnd)
    }

}

在尝试初始化类中的变量时,Xcode抛出一个错误,指出someUrlStart是一个let常量.

无法赋值:'someUrlStart'是'let'常量

到目前为止,这是我在代码中所拥有的全部内容,而且我不明白为什么静态var将被视为常量.这是否特定于初始化器？

我的问题是:为什么变量"_random"的行为在定义为静态/非静态时会发生变化？

==>静态定义时:_random.nextDouble()返回真正的随机值.

==>当不是:_random.nextDouble()返回几乎相同的值.

class Shape   
{  
    protected Canvas _canvas;
    protected UIElement _element;
    static Random _random = new Random();

    public Shape(Canvas canvas)
    {
        _canvas = canvas;
    }

    public void Draw()
    {
        double val1 = _canvas.ActualWidth * _random.NextDouble();
        double val2 = _canvas.ActualHeight * _random.NextDouble();
        _element.SetValue(Canvas.LeftProperty, val1);
        _element.SetValue(Canvas.TopProperty, val2);
        _canvas.Children.Add(_element);
    }

}


public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    private void MainWindow_Loaded(object sender, RoutedEventArgs e)
    {
        Shape s1 = new Circle(MemoCanvas);

        for (int i = 0; i < …

我正在完成基础编程课程，但我无法理解类变量和实例变量（静态和非静态）之间的区别。我需要在代码中确定两者之间的区别

Class StudentDetails\n{\nInt rollNumber;\nString studentName;\n}\nStudentDetails firststudent= StudentDetails (19236, \xe2\x80\x9dThomas\xe2\x80\x9d);\n

我相信 rollNumber、studentName、19236 和“Thomas”都是实例变量，firststudent 是类变量。

任何有关这方面的帮助将不胜感激，因为课程材料不是很有帮助。

如果我有一个静态变量（假设是 foo），其值从另一个静态变量继承，后来我更改了另一个静态变量的值，然后尝试访问 foo ，它仍然给出初始化时使用的旧值。

我有一个包含以下代码的文件endpoints.dart

class EndPoints {

  static String baseUrl = "someurl.com/";

  static String place = baseUrl + "api/v1/place";

}

在这里，如果我更改任何其他文件中的baseUrl并像这样打印它

onPressed () {
 
 print(EndPoints.place);
 //prints someurl.com/api/v1/place

 EndPoint.baseUrl = "changedurl.com/";

 print("${EndPoints.baseUrl}");
 //prints changedurl.com/

 print("${EndPoints.place}");
  //still prints someurl.com/api/v1/place
}

我担心的是为什么static String place = baseUrl + "api/v1/place" 不采用更新后的baseUrl值。

我是C#的初学者,也是OOP的初学者.

在C#中总结来自外部函数的两个静态变量时,我感觉很有趣.

这是我的代码.

using System;

namespace StaticFun
{
    class StaticFun
    {
        public static int a;
        public static int b;

        public void count()
        {
            a++;
        }

        public void mount()
        {
            b++;
        }

        public static int getsum()
        {
            return a + b;
        }
    }

    class Program
    {
        static void Main(String[] args)
        {
            StaticFun obj = new StaticFun();

            obj.count();
            obj.count();
            obj.count();
            Console.WriteLine("Value of a for obj : {0}.", StaticFun.a);

            obj.mount();
            obj.mount();
            Console.WriteLine("\na = {0}\nb = {0}\nSum : {0}.", StaticFun.a, StaticFun.b, StaticFun.getsum());

            Console.ReadKey();
        } …

class ClassObject {
public:
    ClassObject();
    virtual ~ClassObject();
private:
    int x;
 };

int ClassObject::x=10;

为什么编译失败？我认为如果可以通过这种方式初始化静态成员,那么对于非静态成员也应该是可能的.

我正在阅读"黑客攻击,剥削艺术"一书,这个代码示例让我很困惑.

它位于全局变量范围的上下文中:

#include <stdio.h>

void function() { // An example function, with its own context
    int var = 5;
    static int static_var = 5; // Static variable initialization
    printf("\t[in function] var = %d\n", var);
    printf("\t[in function] static_var = %d\n", static_var);
    var++; // Add one to var.
    static_var++; // Add one to static_var.
}

int main() { // The main function, with its own context
    int i;
    static int static_var = 1337; // Another static, in a different context
    for(i=0; i …