C�ɂ����鎯�ʎq�̗L���͈͂ƕϐ��̐��������F�ڎw���I C�v���O���}�i9�j�i1/2 �y�[�W�j

�ϐ���֐����v���O�������̂ǂ�����g�����A�ϐ��ɕۑ������l�����‚܂Ŏg���������A�Ƃ������v���ɂ���āA�����̒�`�̎d�����ς��܂��B����́A�v���ɉ����ĕϐ���֐����`�ł���悤�ɂȂ邽�߂ɕK�v�ȁA�^�C���q�A���ʎq�̗L���͈́A�ϐ��̐������Ԃɂ‚��Ċw�т܂��B

» 2011�N04��26�� 10��00�� ���J

�@�O��͊֐��ɂ‚��Ċw�т܂����B���͂ł�������A�֐��̏����A�����ďo�͂ł���߂�l���������ƂŊ֐�����邱�Ƃ��ł��܂����B�����̒P�ʂł܂Ƃ߂Ċ֐��ɂ��邱�Ƃɂ���āA�����̓��e���͂����肵�A���x�ł������������Ăяo����悤�ɂȂ�܂��B

�@����܂ŕϐ���֐����`���A������v���O�����̒��Ŏg���Ă��܂����B��������`��������Ƃ����āA�u���‚ł��ǂ�����ł��g����v�Ƃ����킯�ł͂���܂���B���֗��Ɏg�����߂ɂ́A�I�u�W�F�N�g�̓��������ڂ�����`������A�g�p�ł���͈͂𐧌������肷�邱�Ƃ��K�v�ɂȂ��Ă��܂��B����͕ϐ���֐�������t���邽�߂́g�C���q�h�ƁA�ϐ���֐��̎g����͈͂ɂ‚��Ċw�т܂��傤�B

�^�C���q

�@�^�C���q�́A�ϐ��̌^������̓I�ɐ������邽�߂̃L�[���[�h�ł��B�^�C���q�ɂ͎���3�‚�����܂��B

  • const
  • restrict
  • volatile

�@�^�Ɍ^�C���q��g�ݍ��킹�邱�ƂŁA�^�̈Ӗ�������̓I�ɂȂ�A�p�r�𖾊m�ɂ��邱�Ƃ��ł��܂��B�Ⴆ�Ό^int�ɏC���qconst��g�ݍ��킹�邱�ƂŁA������int�ł͂Ȃ��A���̌�ɐ�������悤�ȁuconst�Ƃ���������������int�^�v��\�����邱�Ƃ��ł��܂��B

�@�^�C���q�͂��̂悤�Ɍ^�̈Ӗ�����̓I�ɂ��邽�߂ɗp�ӂ���Ă���̂ŁA��Ɍ^�ƂƂ��ɗp�����A�P�Ƃœo�ꂷ�邱�Ƃ͂���܂���B

�@�����ł�const��volatile�ɂ‚��Đ������܂��Brestrict�ɂ‚��Ă͂����������ƂŎ��グ�܂��B

(1) const

�@const�ŏC�����ꂽ�^�̃I�u�W�F�N�g�i�ϐ��j�́A�v���O�����̒��Œl��ύX�ł��Ȃ��Ȃ�܂��B�‚܂�A���̂悤�ȑ��삪�ł��܂���B

const int a = 0; // const int�^�̕ϐ�a���`���ď���������B
a = 1; // �R���p�C���G���[�I const int�^�̕ϐ��͒l��ύX�ł��Ȃ��B

�@���̕��@�͊֐��̈����ł��g���܂��B

#include <stdio.h>
#include <stdlib.h>
 
double add(const double a, const double b) {
  // a = 0.3; �G���[
  return a + b;
}
 
int main(void) {
  double x = 0.1;
  double y = 0.2;
  double sum = add(x, y);
  printf("%f\n", sum); // 0.300000
  return EXIT_SUCCESS;
}

�@������a�ɂ�0.1���Ab�ɂ�0.2������܂��B�֐�add�̒��ł�a��b�̒l��ύX���邱�Ƃ��ł��܂���B����ɂ�2�‚̃����b�g������܂��B

  • �����a��b�̒l��ύX���Ă��܂��悤�ȃR�[�h�������Ă��܂����Ƃ��Ȃ��i���Ƃ������Ă��܂��Ă��R���p�C�������o���Ă����j
  • �֐�add�̎�����m��Ȃ��l�ɂ��A�֐�add����a��b�̒l���ύX����Ȃ��Ƃ������Ƃ����m�ɕ�����

�@��҂̃����b�g�ɂ‚��ẮA���܂łɐ��������͈͓��ł͖��ɂȂ�܂���B�֐�add�̒���a��b�̒l���ύX����Ă��Amain�̎��s�ɂ͉����e�����y�ڂ��Ȃ�����ł��B

�@�������|�C���^�i�|�C���^�^�ɂ‚��Ă͍���̋L���Ő�������\��ł��j�Ƃ������̂��g�p���邱�Ƃɂ���āA�Ăяo�����̕ϐ��̒l���A�Ăяo���ꂽ�֐��̒��ŕύX�ł���悤�ɂȂ�܂��B���̂Ƃ��ɂ́A�ϐ��̒l���ύX�����̂��A����Ƃ��ύX����Ȃ��̂��A�Ƃ������Ƃ��֐����Ăяo�����ɖ��m�Ɏ������Ƃ́A���̊֐����g���l�ɂƂ��āA�ƂĂ��L�v�ȏ��ɂȂ�܂��B��������������Ƃ����C�����Ŋ֐��̎g������͂ƂĂ��ǂ��Ȃ�܂�����ϋɓI�Ɏg���܂��傤�B

(2) volatile

�@���܂ň����Ă����ϐ��́A�l��ύX���邽�߂ɂ͑�����Z�q�i'='��'+='�Ȃǁj���g���Ă��܂����BC�R���p�C�����A���̂��Ƃ�O��ɃR���p�C�����s�Ȃ��܂��B

�@�ϐ��̌^��volatile�C���q��t����ƁA���̕ϐ��͎��̂悤�ȓ��������‚��Ƃ�\���܂��B

  • �v���O�����̃R�[�h�ŕϐ��̒l��ς��Ȃ��Ă��A����ɒl���ς��”\��������
  • �ϐ��̒l��ς��悤�Ƃ���ƁA�l���ς��ȊO�̓��������”\��������

�@�������A�v���O���}���܂������m��Ȃ���������Ă�����Ă͍���܂��B���̕ϐ����ǂ̂悤�ȓ�������邩�m��Ȃ��̂�C�R���p�C���ł����āA�v���O���}�͒m���Ă��Ȃ���΂Ȃ�܂���B

�@volatile�͎�ɑg�ݍ��݃v���O���~���O�ŗ��p���܂��B�������ȕϐ��̓v���O�����������Ă���CPU�Ƃ͕ʂ̃f�o�C�X�̏�Ԃ�\���Ă���A���̃f�o�C�X�̏�Ԃ��ς��Ƃ��̕ϐ��̒l���ς��A�Ƃ����悤�ȃP�[�X������܂��B

�@�v���O���}�̓f�o�C�X�̏�Ԃ��ς�����炠��ϐ��̒l���ς��Ƃ������Ƃ�m���Ă��܂����AC�R���p�C���͒m��܂���B����C�R���p�C�����u����ɒl���ς��”\��������v���Ƃ�m��Ȃ��܂܃R���p�C������ƁA�v���O���}�Ɏ���ēs���������߂���Ă��܂��ꍇ������܂��B

�@�Ⴆ�Ύ��̃R�[�h�͂ǂ��ł��傤���B

int main(void) {
  int a = 1;
  if (a) { // if���͏������̒l��0�ȊO�Ȃ�^�ƂȂ�A�����u���b�N�����s�����B
    printf("���̃��b�Z�[�W�͕\�������H\n");
  }
  return EXIT_SUCCESS;
}

�@�ϐ�a�̒l���ς��Ȃ��Ȃ�΁Aif���̃u���b�N�͕K�����s����܂��B�R�[�h���������ϐ�a�̒l��ύX���Ă��܂��񂩂�Aif�̏�������]������̂��͂����薳�ʂƌ����܂��B����C�R���p�C���Ȃ�΂���͖��ʂł���Ɖ��߂��Aif�����폜����printf��K�����s����悤�ȃv���O�����𐶐����Ă���܂��B���̂悤�ȏ������g�œK���ioptimization�j�h�ƌĂт܂��B

�@���̍œK�����s���Ă��L�q�ʂ�Ƀv���O�����͓��삵�܂����Aif�����Ȃ��Ȃ镪�����v���O�����̓���͑����Ȃ�܂��B�������ϐ�a���u����ɒl���ς��”\��������ϐ��v���Ƃ����獢�������ƂɂȂ�܂��Bif�������s����O��a�̒l��0�ɂȂ��Ă���”\�������邩��ł��B�Ƃ������Ƃ́A����C�R���p�C���ł�if��������ɍ폜���Ă��炤�킯�ɂ͂����܂���B

�@���̂悤�ȏꍇ��volatile���g�p���܂��Bvolatile�ŏC�����ꂽ�^�����•ϐ��͂��̂悤�ȍœK�����s���Ȃ��悤�ɂȂ�܂��B

int main(void) {
  // volatile�C���q���‚����̂ōœK������Ȃ��B
  volatile int a = 1;
  if (a) {
    printf("���̃��b�Z�[�W�͕\������邩������Ȃ����A�\������Ȃ���������Ȃ��B\n");
  }
  return EXIT_SUCCESS;
}

���ʎq�̗L���͈́i�X�R�[�v�j

�@�I�u�W�F�N�g�i�ϐ��j��֐��Ȃǂɂ͖��O���t���Ă��܂��B��������ʎq�ƌĂт܂��B

�@�����I�ɂ́A1�‚̎��ʎq��1�‚̃I�u�W�F�N�g��֐����w�������Ă���ƍl�����܂����A���ۂɂ͂����ł͂���܂���B�������ʎq�������̃I�u�W�F�N�g��֐���\�����Ƃ�����܂��B

�@�Ⴆ�΁A�u�N���m��Ȃ��l���������v���O�����Ŏg�p���ꂽ�I�u�W�F�N�g�̎��ʎq�́A�����̃v���O�����̒��ł͎g���Ȃ��v�Ƃ������ƂɂȂ�ƁA�����ɕs�ւł��B���̂��ߎ��ʎq�ɂ́A���̎��ʎq���L���ƂȂ�͈́i�X�R�[�v�j�����܂��Ă���A���̗L���͈͂̒��ł̂݁A����1�‚̃I�u�W�F�N�g��֐����w�������Ă��܂��B

(1) �u���b�N�L���͈�

�@�ł������I�ȗL���͈͂̓u���b�N�i�������j�ł��傤�B�������ʓI�Ɂg�u���b�N�L���͈́h���邢�́g�u���b�N�X�R�[�v�h�ƌĂт܂��B��قǂ̃T���v���ŗL���͈͂��m�F���Ă݂܂��B

#include <stdio.h>
#include <stdlib.h>
 
double add(const double a, const double b) {
  // a = 0.3; �G���[
  return a + b;
}
 
int main(void) {
  double x = 0.1;
  double y = 0.2;
  double sum = add(x, y);
  printf("%f\n", sum); // 0.300000
  return EXIT_SUCCESS;
}

�@9�s�ڂ���n�܂�֐�main�ł́Ax�Ay�Asum�Ƃ���3�‚�double�^�̃I�u�W�F�N�g��錾���Ă��܂��B�����̎��ʎq�̗L���͈͂́u�錾���ꂽ�ꏊ�v����u�u���b�N�̏I���i���̗�ł͊֐��̏I���Ɠ����j�v�܂łł��B

  • x �F 10�s�ڂ̐錾�̌�납��15�s�ڂ̊֐��I����\��'}'�̑O�܂�
  • y �F 11�s�ڂ̐錾�̌�납��15�s�ڂ̊֐��I����\��'}'�̑O�܂�
  • sum �F 12�s�ڂ̐錾�̌�납��15�s�ڂ̊֐��I����\��'}'�̑O�܂�

�@���ʎqsum�̗L���͈͂�12�s�ڂ���ł�����A10�s�ڂ�11�s�ڂŎ��ʎqsum���g�p���邱�Ƃ͂ł��܂���B�������A�֐�add�̒��Ŏg�p���邱�Ƃ��ł��܂���B�����֐�main��add�̏㉺�̈ʒu���t�ł������ŁA���̊֐��Ő錾���ꂽ���ʎq���g�p���邱�Ƃ͂ł��܂���B

�@�{�A�ڂ̑�3��Łu�ϐ��𗘗p����O�ɕK���錾���K�v�v�Ƒ�G�c�Ȑ��������܂������A�����ŗL���͈͂ɂ‚��Đ��m�ɗ�������悤�ɂ��Ă��������B�Ȃ��A�錾�������s����ϐ��̗L���͈͂��J�n�����Ƃ������Ƃ͓�����O�̂悤�Ɏv����������܂��񂪁A����̓v���O���~���O����ɂ���ĈႢ�܂��B�g�p����ϐ����̐錾�̓u���b�N���̂ǂ��ł��悢�A�Ƃ����d�l�ƂȂ��Ă�����̂�A���������錾���K�v�Ȃ����̂�����܂��B�C��t���܂��傤�B

�@�����ł͊֐��ɂ�����u���b�N�̗�ł������A���̃u���b�N�A�Ⴆ��if���ɑ����u���b�N��for���̃u���b�N�Ȃǂł������ł��B

ubNL͈ �u���b�N�L���͈�

�@�I�u�W�F�N�g�̗L�����Ԃɂ̓u���b�N�L���͈͂̑��ɁA�g�t�@�C���L���͈́i�t�@�C���X�R�[�v�j�h�Ɓg�v���g�^�C�v�L���͈́i�v���g�^�C�v�X�R�[�v�j�h�Ƃ������̂�����܂��B

(2) �t�@�C���L���͈�

�@�ϐ��͊֐��̊O���ɂ��u�����Ƃ��ł��܂��B���̏ꍇ�A�ϐ��̎��ʎq�̓t�@�C���L���͈͂������܂��B�t�@�C���L���͈͕͂ϐ����錾���ꂽ�ꏊ����AC�\�[�X�t�@�C���̏I���܂łł��B

t@CL͈ �t�@�C���L���͈�

�@�t�@�C���L���͈͂́A�����̃\�[�X�t�@�C�����������ĂЂƂ‚̃v���O�����Ƃ���Ƃ��Ɉӎ�����K�v������܂��B����\�[�X�t�@�C���Ő錾���ꂽ���ʎq�́A�ʂ̃\�[�X�t�@�C���ŎQ�Ƃ��邱�Ƃ͂ł��܂���B

(3) �v���g�^�C�v�L���͈�

�@����͂��܂�ӎ�����K�v�͂���܂���̂ŊȒP�ɏЉ�܂��B

�@�v���g�^�C�v�L���͈͂́A�֐��v���g�^�C�v�Ŏg����I�u�W�F�N�g���ʎq�̗L���͈͂ł��B�v���g�^�C�v�錾�̉������Ɏg���鎯�ʎq�́A���̐錾�̒��ł����L���ł��B�֐��v���g�^�C�v�錾�ŗ��p�������ʎq�𑼂̏ꏊ�ŗ��p���邱�Ƃ͂ł��܂���B

(4) �L���͈͂̒��ӎ���

�@���̂悤�ɐ錾�����ꏊ�ɂ���ĕϐ��̎��ʔ͈͂��قȂ�܂��̂ŁA�ǂ̏ꏊ�łǂ̎��ʎq���L���ɂȂ��Ă��邩��c�����邱�Ƃ͏d�v�ł��B

�@�܂��A�������O�Ɠ����L���͈͂����•����̎��ʎq��錾���邱�Ƃ͂ł��܂���B

void func(void) {
  int a = 0;
  // ...
  int a = 1; // �R���p�C���G���[�I redefinition of 'a'. ('a'���Ē�`����Ă��܂��B)
}

�@�������O�ł����Ă��ʂ̗L���͈͂����•����̎��ʎq��錾���邱�Ƃ͂ł��܂��̂ŁA�������ʎq�����•����̃I�u�W�F�N�g�̗L���͈͂��d�Ȃ邱�Ƃ�����܂��B

// �t�@�C���L���͈͂����•ϐ�a��錾�����B
int a = 0;
void func(void) {
  // �u���b�N�L���͈͂����•ϐ�a��錾�����B
  int a = 1;
  // a = 0�H a = 1�H
  printf("a = %d\n",a);
}

�@���̗�ł�2�‚̓������ʎq�����•ϐ�a���o�ꂵ�܂��B���ʎq�͓����ł����L���͈͈͂قȂ�A������t�@�C���L���͈͂ŁA����������u���b�N�L���͈͂ł��B�֐�func�̒��Ŏ��ʎqa���Q�Ƃ��悤�Ƃ��Ă��܂����A���̉ӏ��ł͎��ʎqa�����—����̕ϐ��ɂ‚��ėL���͈͂ɓ����Ă��܂��B

�@���̂悤�ɕ����̎��ʎq���L���ȏꏊ�ł́A�����̗L���͈͂����Ž��ʎq���Q�Ƃ���܂��B�u���b�N�L���͈͂̓t�@�C���L���͈͂̓����ɂ���܂��B�‚܂�u���b�N�L���͈͂����Ž��ʎqa���Q�Ƃ���邽�߁A���̗��printf�֐��Ăяo���ł́ua = 1�v���\������܂��B���̂��Ƃ̓u���b�N������q�ɂȂ��Ă���ꍇ�ł������ŁA���ꂼ��̃u���b�N�œ������ʎq�̃I�u�W�F�N�g��錾�����ꍇ�A�����̃u���b�N�ł͓����̕ϐ����Q�Ƃ���܂��B

�@�Ȃ��A���ʎq�̗L���͈͂��d�Ȃ��Ă���Ƃ���ł́A�O���̎��ʎq���Q�Ƃ�����@�͂���܂���B

�@�܂��A�I�u�W�F�N�g�i�ϐ��j�Ɗ֐��̗L���͈͂ɂ‚��Ă͈����������Ȃ̂ŁA�������ʎq�œ����t�@�C���L���͈͂����•ϐ��Ɗ֐��𓯎��ɐ錾���邱�Ƃ͂ł��܂���B���������x���̗L���͈͂ɂ‚��Ă͈������ʂɂȂ��Ă���̂ŁA�������ʎq�œ����u���b�N�L�����Ԃ����•ϐ��ƃ��x���͓����ɐ錾���邱�Ƃ��ł��܂��B

int a = 0;
// �������ʎq�A�����t�@�C���L���͈͂����•ϐ���֐����A�����錾���邱�Ƃ͂ł��Ȃ��B
/* double a = 0.0; �R���p�C���G���[�I */
/* void a(void) {} �R���p�C���G���[�I */
void func(void) {
  // �L���͈͂��قȂ��OK�B
  int a = 0;
  // ���x���͕ʂ̈����Ȃ̂�OK�B
a:
  // �������ʎq�A�����u���b�N�L���͈͂����ƒ��x�����A�����錾���邱�Ƃ͂ł��Ȃ��B
/* a: �R���p�C���G���[�I */
}

�R�������ϐ��̐錾�ʒu�ƌ^���̏ȗ�

�@C99���O��C�ł́A�ϐ��̓u���b�N�̐擪�ɂ܂Ƃ߂Đ錾����K�v������܂����BC99�ł͂��̐����͂Ȃ��Ȃ��Ă��邽�߁A���̂悤�ȃR�[�h���������Ƃ��ł��܂��B

#include <stdio.h>
#include <stdlib.h>
int a = 1;
int main(void) {
  printf("a = %d\n", a); // a = 1
  int a = 2;
  printf("a = %d\n", a); // a = 2
  return EXIT_SUCCESS;
}

�@C99�ɑΉ������R���p�C���ł���΁A���̃R�[�h�͖��Ȃ��R���p�C���ł��܂��BGCC�Ȃǂ̈ꕔ�̃R���p�C���ł́AC99�ɑΉ����Ă��Ȃ��Ă��Ǝ��g���őΉ����Ă�����̂�����悤�ł��BVisual C++�͎c�O�Ȃ���C99�ɑΉ����Ă��Ȃ����߁A���̃R�[�h�̓G���[�ɂȂ�܂��B�ϐ��̐錾�̓u���b�N�̐擪�ɂ܂Ƃ߂ď����܂��傤�B���̏ꍇ�ł��L���͈͂ɂ‚��Ă͓����ƍl���č����x������܂���B

�@�܂��AC99���O��C�ł́A�I�u�W�F�N�g�̐錾���Ɍ^�����ȗ����邱�Ƃ��ł��܂����B�ȗ������int�Ƃ��ĉ��߂���܂��B�‚܂�uconst a = 1�v�Ə����ƁA�ϐ�a��int�^�Ƃ��Ĉ����Ă��܂����BC99�ł͏ȗ��ł��Ȃ��Ȃ������߁A�uconst int a = 1�v�Ə����K�v������܂��BC99���O�̃R�[�h�ł�int���ȗ����ď����ꂽ���̂����邩������܂��񂩂�A�o���Ă����Ɨǂ��ł��傤�B


Index

C�ɂ����鎯�ʎq�̗L���͈͂ƕϐ��̐�������

Page1
�^�C���q
���ʎq�̗L���͈́i�X�R�[�v�j

Page2
�I�u�W�F�N�g�i�ϐ��j�̋L�������
����w�񂾂���


�@�@�@�@�@�@ 1|2 ���̃y�[�W��

Copyright © ITmedia, Inc. All Rights Reserved.

'; this.insertTarget = document.querySelector('#cmsBody .subscription') || document.querySelector('#cmsBody .inner'); }; BodyAdIMSWithCCE.prototype = Object.create(BodyAdContent.prototype); BodyAdIMSWithCCE.prototype.activate = function () { refreshGam('InArtSpecialLink'); } // global reference window.itm = itm; //entry point BodyAdEventBase.polyfill(); const bodyAdManager = BodyAdManager.getInstance(); bodyAdManager.addEventListener(BodyAdManager.EVENTS.READY, function (ev) { bodyAdManager.loadAdvertise(); }); bodyAdManager.init(); })();
�X�|���T�[����̂��m�点PR

���ڂ̃e�[�}

Microsoft  WindowsőO2025
AI for GWjAO
[R[h^m[R[h Zg by IT - ITGWjArWlX̒SŊ􂷂gD
Cloud Native Central by IT - XP[uȔ\͂gD
�V�X�e���J���m�E�n�E �y�����i�r�zPR
���Ȃ��ɂ������߂̋L��PR

RSS�ɂ‚���

�A�C�e�B���f�B�AID�ɂ‚���

���[���}�K�W���o�^

��IT�̃��[���}�K�W���́A �������A���ׂĖ����ł��B���Ѓ��[���}�K�W�������w�ǂ��������B